Everything about JetPad, in one place

Overview

JetPad 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.

JetPad never holds your funds. Every launch and every trade is a transaction your own wallet asks you to approve, sent to a contract that cannot hold a balance between transactions.

What JetPad does not have

There is no bonding-curve phase, no migration, and no graduation. Most launchpads sell from an off-DEX curve first and move the liquidity to a real pool later; until that moment the token has no pool, so scanners cannot read it and aggregators cannot list it.

A JetPad coin skips that stage entirely. The pool is real, the liquidity is burned, and the token is tradable in the same transaction that creates it. There is no later event to wait for, and no step at which anything moves.

How launches work

Creating a launch runs one atomic transaction. It deploys the ERC-20, opens its Uniswap v4 pool against native ETH, deposits 100% of the supply as a single-sided position, mints the position NFT directly to 0x…dEaD, arms the 1% fee, and executes the creator's first buy. If any part fails, none of it happened.

A single-sided position is a bonding curve

This is not an analogy. A liquidity position L over a price range [a, b] behaves exactly like a constant product with virtual reserves:

(x + L/√b) · (y + L·√a) = L²        for every price P in [a, b]

virtual ETH reserve    V_e = L / √b
virtual token reserve  V_t = L · √a
constant               k   = L²

So the curve everyone expects is there. JetPad just expresses it in Uniswap's own representation instead of a bespoke contract — which is precisely why there is nothing left to migrate afterwards, and why the pool is readable by every scanner and aggregator from the start.

The pool opens at the top of the range holding only tokens and zero ETH. Buys push the price down the range in Uniswap's orientation, which in human terms means the price in ETH per token goes up. The ETH that buyers deposit is what pays sellers — which is what makes a coin sellable from the very first trade, with no condition and nothing to unlock.

The creator's first buy

Every launch includes a buy by the creator, in the same transaction, at the floor price. It is required, and the minimum is 0.01 ETH.

The cap on the first buy

The atomic first buy cannot exceed 50% of the supply (MAX_DEV_BUY_BPS = 5000). That limit is a constant in the bytecode — no admin can raise it, which is what makes it a guarantee rather than a policy.

The opening market cap is deliberately low, and you should size that before you buy: at the STANDARD tier it is about 2.47 ETH, so 1 ETH buys roughly 29% of the supply. Both the ETH spent and the tokens received by the creator are published in the CoinCreated event, and shown on every coin's page.

Trading and pricing

Every token trades against native ETH in its own Uniswap v4 pool. The price you see is the live pool price and it moves with every trade. What you actually receive can differ from the quote; slippage is how much of that movement you agree to accept.

Trades are routed through JetstreamRouter, a contract with no owner, no proxy, no pause, no sweep function, no Permit2 dependency, and no ability to hold a balance between transactions. The JetPad interface refuses to send anything to any other target.

Launch tiers

A tier sets the price range of the launch position, and therefore the opening market cap. All three tiers share the same range width (55,800 ticks), so all three have the same ceiling — a ×265 move from the floor to the top of the range. Only the scale in ETH changes.

These are the values actually reached, re-derived from the rounded ticks — never the requested bounds. Uniswap only accepts ticks on a 200 grid, so the grid moves the numbers by +0.5% to −1.1%, and the honest figure to publish is the one on chain.

The buyout cost is what lands in the pool, so it is net of the hook fee: a buyer actually pays cost / (1 − 0.01).

Fees

There is one fee: 1% of every swap, taken by JetstreamHook on the ETH leg. It is always paid in ETH, never in the memecoin, from the very first trade.

The pool's own LP fee is zero. The hook is the only source of fees in the system, which is what lets the liquidity position be burned and still produce revenue — the fee belongs to the swap, not to whoever holds the liquidity.

How the 1% is split

The fee rate is capped at 300 bps by a constant in both the factory and the hook. It is 100 bps today. There is no creation fee: creationFee is 0.

Creator rewards

Fees accumulate per pool as pendingEth[poolId], held as ERC-6909 claims on the Uniswap PoolManager. Turning them into real ETH takes two permissionless steps:

// 1. Split what has accrued. Anyone can call this, for any number of pools at once.
//    The proceeds are credited to the beneficiaries, never to the caller.
hook.harvest(bytes32[] poolIds)

// 2. Withdraw your own balance. address(0) means native ETH.
hook.claim(0x0000000000000000000000000000000000000000)

Both are available from the profile panel in the JetPad interface, which shows each of your coins, its market cap, and what it currently has waiting.

The creator role can be handed over with a two-step transfer — transferCreator(poolId, to) then acceptCreator(poolId) from the new address. It moves the fee stream and nothing else: it grants no power over the liquidity, which is burned, or over trading.

What is guaranteed

These are properties of deployed bytecode, each one verifiable by anyone without trusting JetPad.

Risk disclosures

Tokens launched through JetPad are user-created and experimental. Before signing, review the token address, the creator, the liquidity, the holder concentration and the transaction preview.

• Prices can move quickly and liquidity can be thin.
• Similar names and images can represent completely unrelated tokens.
• A creator's first buy can be as large as half the supply. Check who holds what.
• Smart contracts, wallets, RPCs and indexers can fail.
• Displayed values are estimates, not execution guarantees.
• The contracts have not been reviewed by an external auditor.

JetPad is an interface. It is not investment advice, and it is not a statement about any token's quality.

Network

A small, verifiable integration surface. Everything reads off the contracts — index the factory and the pool events and you have a trust-minimised source of truth that does not depend on JetPad being up.

Contracts

Deployed addresses on Robinhood Chain. Contracts are immutable: a new version ships as new addresses, listed here.

Hostile addresses

JetPad refuses these addresses in two independent places — in the browser before signing, and in the API before it will name any call target at all. Duplicating that check is deliberate: this is the one class of mistake that cannot be undone.

Onchain events

Index CoinCreated on the factory, then the PoolManager's Swap events filtered by each poolId. Onchain events are the authoritative source of truth, and no eth_call is needed: CoinCreated carries the entire launch position.

event CoinCreated(
  address indexed token,
  address indexed creator,
  bytes32 indexed poolId,
  string  name,
  string  symbol,
  string  tokenURI,        // IPFS CID
  uint256 totalSupply,     // always 1e27
  uint256 positionTokenId, // NFT minted to 0x…dEaD — the burn proof
  uint160 sqrtPriceX96,    // opening price, exactly sqrt(tickUpper)
  uint128 liquidity,
  int24   tickLower,
  int24   tickUpper,
  uint8   tier,            // 0 LOW · 1 STANDARD · 2 PREMIUM
  uint16  feeBps,          // frozen for this pool (100 = 1%)
  uint256 devBuyEth,       // ETH the creator's first buy actually spent
  uint256 devBuyTokens,    // tokens they received — display this
  uint16  implVersion      // 3 = single-sided launch
);

// topic0
0xef85cf514fdefb3937035e5e5f9200299d6354dae086a76b9271b5e363ebab07

// Written once per coin, by the factory, during creation.
event PoolRegistered(bytes32 indexed poolId, address indexed token, address indexed creator, uint16 feeBps);

// Emitted on EVERY swap. This is the coin's revenue, with no state read at all.
// `takenBeforeSwap` says which leg paid; the amount is always in wei of ETH.
event HookFeeAccrued(bytes32 indexed poolId, uint256 amount, bool takenBeforeSwap);

// A treasury movement, not new revenue. Do not double-count it against the above.
event HookFeesHarvested(bytes32 indexed poolId, uint256 amount);

event CreatorTransferStarted(bytes32 indexed poolId, address indexed from, address indexed to);
event CreatorTransferred(bytes32 indexed poolId, address indexed from, address indexed to);

// role: 0 = DEV · 1 = BUYBACK · 2 = PLATFORM. asset(0) = native ETH.
event FeesAccrued(address indexed account, address indexed asset, uint256 amount, uint8 role);
event FeesClaimed(address indexed account, address indexed asset, uint256 amount);

The PoolKey, and deriving the poolId

A v4 pool has no address of its own. It is identified by the hash of its key, and every JetPad pool has the same shape:

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 launches = await client.getLogs({
  address: "0x4c0cdfB2cb5D38F58e20152C7B9dCFb39019A52f",
  event: parseAbiItem(
    "event CoinCreated(address indexed token, address indexed creator, bytes32 indexed poolId, string name, string symbol, string tokenURI, uint256 totalSupply, uint256 positionTokenId, uint160 sqrtPriceX96, uint128 liquidity, int24 tickLower, int24 tickUpper, uint8 tier, uint16 feeBps, uint256 devBuyEth, uint256 devBuyTokens, uint16 implVersion)",
  ),
  fromBlock: 23628017n,   // the factory's first block — earlier is wasted work
  toBlock: "latest",
});

Reading token state

Every launch token is self-describing on chain, and the factory answers everything else about the launch.

function name()        view returns (string)
function symbol()      view returns (string)
function decimals()    view returns (uint8)     // 18
function totalSupply() view returns (uint256)   // 1e27, fixed
function tokenURI()    view returns (string)    // IPFS CID: image, description, links
function factory()     view returns (address)
function owner()       pure returns (address)   // always 0x0 — a constant, not storage

// ⚠️ `curve()` is a legacy name kept so an external ABI does not break. It returns the
//    factory, which received the supply and put all of it in the pool in the same
//    transaction. It confers no power of any kind.
function curve()       view returns (address)

poolIdOf(address token)            returns (bytes32)   // the pool's identity
poolKeyOf(address token)           returns (PoolKey)
positionTokenIdOf(address token)   returns (uint256)   // 0 = unknown to this factory
launchParams(uint8 tier)            returns (tickLower, tickUpper, sqrtPriceX96Init, liquidity)
launchEconomics(uint8 tier)         returns (startingMarketCapWei, fullBuyoutCostWei, finalMarketCapWei)
coinCount()                          returns (uint256)
feeBps() devBps() buybackBps()      // the CURRENT defaults for NEW coins

configOf(bytes32 poolId)   returns (set, creator, feeBps, devBps, buybackBps)
feeBpsOf(bytes32 poolId)   returns (uint16)    // 0 = not a JetPad pool
creatorOf(bytes32 poolId)  returns (address)
pendingEth(bytes32 poolId) returns (uint256)   // accrued, not yet harvested

// selectors, if you are building calldata by hand
// pendingEth(bytes32)  0x4943253a
// harvest(bytes32[])   0x13df2c7a
// devBps()             0x78b2c179

To verify the burn — the one check worth doing on any coin — take positionTokenId from CoinCreated and call ownerOf(positionTokenId) on the Uniswap PositionManager. It returns 0x…dEaD, and it does so from the coin's very first block.

Pricing

The launch event carries enough to rebuild the whole curve off chain, with no RPC call. Prices after that come from the PoolManager's Swap events on the coin's poolId.

// currency0 is native ETH, so Uniswap's P is TOKENS per ETH.
// Human price (ETH per token) is 1/P — it goes UP as people buy.

ratio          = sqrtPriceX96 / 2**96
tokensPerEth   = ratio * ratio
ethPerToken    = 1 / tokensPerEth
marketCapWei   = totalSupply / tokensPerEth

// The equivalent virtual reserves, if you prefer curve terms:
sqrtA          = sqrtPriceX96AtTick(tickLower)
sqrtB          = sqrtPriceX96                    // opening price IS the upper bound
virtualEthWei  = liquidity / sqrtB
virtualTokens  = liquidity * sqrtA
k              = liquidity ** 2

// ETH needed to buy the entire supply, net of the 1% hook fee:
fullBuyoutWei  = liquidity * (1/sqrtA - 1/sqrtB)

For USD figures, multiply by any ETH/USD source. The JetPad interface uses a spot feed and applies it to the ETH-denominated numbers; it never derives a USD price on chain.

Public API

A read API sits in front of the indexer for convenience — charts, search, quotes. It is a convenience layer over the chain, never an authority: everything it returns is derived from the events above, and anything that matters should be verified against them.

https://api-production-ecec.up.railway.app

A WebSocket on the same host pushes new coins, trades and candle updates as they are indexed. The interface uses it instead of polling, because at 100 ms blocks polling is always behind.

Support

If you are indexing launches, deriving prices, wiring trades or verifying onchain state, reach out and we will help you get it right.

@Jetstreamtrade on X

Versioning

Deployed contracts are immutable. New versions ship as new factory and hook addresses, listed under Contracts. implVersion in CoinCreated tells you which launch mechanism produced a given coin — 3 is the single-sided launch described here.

Terms and attribution

Onchain data is public and free to read. You are responsible for what you do with it. JetPad is provided as is, without warranties, and we are not liable for losses arising from integrations, interfaces, RPCs or indexers.

• Do not present third-party services as operated by JetPad.
• Do not use the JetPad name or marks in a way that misleads users.
• Availability of the interface and of public infrastructure is not guaranteed.