Everything about pons, in one place.

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

pons never holds your funds. Every launch and trade is a transaction your wallet asks you to approve.

Creating a launch deploys the token and its trading pool in a single transaction, and the pool's liquidity is locked automatically. The creator sets the name, symbol, image, description, links, and fee wallet at creation.

Every token trades against WETH in its own pool. There is no bonding curve and no migration later. Buys and sells happen in that same pool from the moment it launches.

1. 01

   Create

   The token is minted with a fixed supply and its WETH pool goes live in the same transaction.

2. 02

   Trade

   Buys and sells run against WETH in the locked pool and move the price.

3. 03

   Graduate

   The launch graduates once enough WETH is paired, and trading continues in the same pool.

Each launch uses a fixed supply of one billion tokens, a 1% pool fee, and a small 0.0005 ETH launch fee.

Every token trades against WETH in its own liquidity pool. The price you see is the live pool price, and it moves with each trade. The amount you actually receive can differ slightly from the quote. Slippage sets how much of that movement you accept.

Price

The current pool price for one token.

Market cap

Price multiplied by circulating supply.

FDV

Price multiplied by the full token supply.

Price impact

The pool movement caused by the size of your trade.

Slippage

The maximum execution movement your transaction accepts.

Liquidity

Assets available in the pool around the current price.

A launch graduates once the WETH paired in its locked pool reaches the threshold. The default threshold is 4.2 ETH, and the progress line tracks how close a launch is.

Graduation only confirms the threshold was reached. It is not a quality signal and does not guarantee future liquidity, price, or an exit.

Trading continues in the same pool after graduation. Nothing moves or migrates.

Trading generates liquidity fees in both the token and WETH. The protocol keeps a share and the creator keeps the rest. The creator can claim their share from the pons interface at any time.

The split is snapshotted for each token when it launches and never changes afterward. The current 70/30 split applies to tokens launched through the active factory. Tokens from the legacy factory keep the original 90/10 split.

Current launches

Creator 70% · protocol 30% · from block 8991118

Legacy launches

Creator 90% · protocol 10% · from block 8600612

Creator rewards accrue in the token's locked position. When they are available, the creator can claim them at any time. If they go unclaimed, pons automation may claim and route them to the creator payout wallet, so the split is honored either way.

Protocol buybacks use protocol funds to buy PONS and send it to the burn address, which permanently reduces the supply in circulation. Burning does not guarantee a higher price.

A manual buyback is running via an automated TWAP using 80% of protocol fees. This amount is not immutable yet, but will be immutable, decentralized, and automated in a future release.

The remaining 20% of protocol fees go towards infrastructure costs and expanding the pons team.

Buyback

80% of protocol fees, executed as an automated TWAP

Operations

20% of protocol fees toward infrastructure and team

When a token's original creator steps away, the community can take it over. A community takeover, or CTO, transfers the social presence and, where applicable, the creator fee payout to an active community.

Takeovers are requested through the pons CTO form and reviewed by the team. Use it only when a token has been clearly abandoned by its original creator and an active community is requesting control of the creator-fee recipient.

The token, its pool, and its locked liquidity are unaffected. Only the creator payout wallet and creator-facing surfaces change. Approval is administrative and depends on what the token's contracts allow. It is not an endorsement or a statement about a token's safety or value.

Never share a private key or seed phrase. pons will never ask you to send funds to process an application.

Tokens launched through pons 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.

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

pons runs on Robinhood Chain. Tokens launch directly into Uniswap V3 and are quoted against WETH only.

Network

Robinhood Chain

Chain ID

4663

Native asset

ETH

Public RPC

https://rpc.mainnet.chain.robinhood.com

Explorer

robinhoodchain.blockscout.com

Pool fee

10000 (1%)

Launch fee

0.0005 ETH

Supply

1,000,000,000 (1e9)

Deployed addresses on Robinhood Chain. The active factory and locker serve current launches. Legacy addresses remain for tokens deployed before the current version.

For a trust-minimized integration, index the factory's TokenLaunched event, register each emitted pool, and index its Swap events. Onchain events are the authoritative source of truth.

0xdb51ea9ad51ab453a65a4cb7e60c3cb378c9501bb002609f8f97778fb6c4235a

0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67

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: "0xA5aAb3F0c6EeadF30Ef1D3Eb997108E976351feB",
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed deployer, address indexed dexFactory, address pairToken, address pool, uint256 dexId, uint256 launchConfigId, uint256 positionId, uint256 restrictionsEndBlock, uint256 initialBuyAmount)",
  ),
  fromBlock: "earliest",
  toBlock: "latest",
});

Derive trade direction from the swap amounts and the token ordering in the pool:

tokenIsToken0 = token < pairToken
pairSigned    = tokenIsToken0 ? amount1 : amount0
side          = pairSigned > 0 ? "buy" : "sell"

There is no migration event. Poll graduationStatus(token) for graduation, and optionally index token Transfer events for holder balances.

The public RPC times out on wide eth_getLogs ranges. Backfill in bounded block chunks from each contract's start block.

Every launch token is self-describing onchain. Read its metadata and canonical pool directly from the token contract, with no off-chain source required.

import { parseAbi } from "viem";

// The launch token is self-describing onchain.
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)",
  "function description() view returns (string)",
  "function liquidityPool() view returns (address)",
  "function socials() view returns (string twitter, string telegram, string discord, string website, string farcaster)",
]);

const [name, symbol, decimals, logo, pool] = await Promise.all([
  client.readContract({ address: token, abi: tokenAbi, functionName: "name" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "symbol" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "decimals" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "logo" }),
  client.readContract({ address: token, abi: tokenAbi, functionName: "liquidityPool" }),
]);

Launch-level parameters live on the factory that deployed the token. isToken0 is required for pricing and trade direction.

// Launch-level state from the factory that created the token.
const factoryAbi = parseAbi([
  "function getLaunchedToken(address token) view returns ((address token, address deployer, address pairedToken, address positionManager, uint256 positionId, uint256 dexId, uint256 launchConfigId, uint256 restrictionsEndBlock, uint256 supply, bool isToken0, uint24 poolFee, bool exists, uint256 initialBuyAmount) launched)",
]);

const { launched } = await client.readContract({
  address: factory,
  abi: factoryAbi,
  functionName: "getLaunchedToken",
  args: [token],
});

// launched.isToken0            token ordering in the pool (needed for pricing)
// launched.pairedToken         WETH
// launched.poolFee             10000 (1%)
// launched.supply              fixed total supply (1e9 * 1e18)
// launched.restrictionsEndBlock last block where launch limits apply

Social links are available from socials(), and the deployer, paired token, and pool fee are also exposed as public getters on the token itself.

Price comes from the pool's slot0. Square the sqrtPriceX96 ratio, invert it when the token is not token0, then convert to USD with any ETH oracle.

import { parseAbiItem } from "viem";

const [sqrtPriceX96] = await client.readContract({
  address: pool,
  abi: [
    parseAbiItem(
      "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
    ),
  ],
  functionName: "slot0",
});

// Token and WETH both use 18 decimals, so no decimal scaling is needed.
const ratio = Number(sqrtPriceX96) / 2 ** 96;
const token1PerToken0 = ratio * ratio;
const priceInWeth = isToken0 ? token1PerToken0 : 1 / token1PerToken0;

// ethUsd from any ETH oracle. The pons interface uses DeFiLlama.
const priceUsd = priceInWeth * ethUsd;
const supplyTokens = Number(supply) / 1e18;
const marketCapUsd = priceUsd * supplyTokens;

// Supply is fixed, so FDV equals market cap unless tokens have been burned.
const fdvUsd = marketCapUsd;

Graduation is a single call. Progress is the paired principal over the threshold, and trading continues in the same pool after it graduates.

const [pairedPrincipal, threshold, graduated] = await client.readContract({
  address: factory,
  abi: [
    parseAbiItem(
      "function graduationStatus(address token) view returns (uint256 pairedPrincipal, uint256 threshold, bool graduated)",
    ),
  ],
  functionName: "graduationStatus",
  args: [token],
});

// 0 through 1. The interface renders this as the progress line.
const progress = Number(pairedPrincipal) / Number(threshold);

To show the creator and protocol split for a token, read the snapshotted share and payout wallet from its locker.

import { zeroAddress } from "viem";

const lockerAbi = parseAbi([
  "function locker() view returns (address)",
  "function tokenProtocolFeeShares(address token) view returns (uint256)",
  "function feeRedirects(address token) view returns (address)",
  "function protocolFeeRecipient() view returns (address)",
]);

// Resolve the locker from the factory rather than hardcoding it.
const locker = await client.readContract({
  address: factory,
  abi: lockerAbi,
  functionName: "locker",
});

const [protocolShare, redirect] = await Promise.all([
  client.readContract({ address: locker, abi: lockerAbi, functionName: "tokenProtocolFeeShares", args: [token] }),
  client.readContract({ address: locker, abi: lockerAbi, functionName: "feeRedirects", args: [token] }),
]);

const creatorSharePercent = 100 - Number(protocolShare);
const creatorPayout = redirect === zeroAddress ? deployer : redirect;

PONS is a graduated token for validating an indexer or integration against known onchain state.

Graduated and trading in the same pool. Launched through the legacy factory.

We offer hands-on support for teams integrating pons. If you are indexing launches, deriving prices, wiring trades, or verifying onchain state, the team can help you get it right.

Reach us at contact@ponsfamily.com for integration questions, technical support, and partnership requests.

Onchain data is public and free to read. You are responsible for how you use it. pons is provided as is, without warranties, and the team is not liable for losses arising from integrations, interfaces, RPCs, or indexers.

When you reference pons, write the name in lowercase and link back to the app. Do not imply a partnership, endorsement, or official status without a written agreement.

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

Agentic launches let Cozzy create and deploy his own token on pons. There is no human in the UI. He picks the name, ticker, image, description, and links, then signs the launch from a wallet he controls.

Onchain, this is the same path as a manual create. The token is minted with a fixed one billion supply, a WETH pool goes live in the same transaction, liquidity is locked, and pons fee routing applies. The only difference is who constructs the metadata and who signs.

1. 01

   Ideate

   Cozzy chooses name, ticker, description, image, and social links for the token he is about to deploy.

2. 02

   Sign

   He loads his dedicated key from the environment, builds the launch payload, and signs for Robinhood Chain (4663).

3. 03

   Deploy

   One POST to the launch API submits the signed transaction. The token and locked WETH pool go live together.

Cozzy uses a dedicated wallet. That wallet is the deployer, the creator-fee recipient, and the signer for the initial buy. Do not reuse a personal trading key.

Keep Cozzy's private key in the environment. Derive the address with privateKeyToAccount and pass that address as wallet in the launch request. Never put the key in client code, git, or these docs.

import { createWalletClient, createPublicClient, http, parseEther } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(
  process.env.COZZY_PRIVATE_KEY,
);

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

// account.address is Cozzy's deployer / creator wallet

Fund Cozzy's wallet with enough ETH for the 0.0005 ETH launch fee, gas, and any initialBuyEth he wants to pair at creation. If the wallet cannot pay those amounts, the launch reverts.

Submit the signed launch through POST https://api.ponsfamily.com/v1/launches. Cozzy owns the fields he can choose. Protocol parameters are fixed by the factory and cannot be overridden in the payload.

wallet

Cozzy's address derived from his key. Must be the signer.

name

Token name. Chosen by Cozzy.

ticker

Token symbol. Chosen by Cozzy.

description

Onchain metadata string stored on the token.

initialBuyEth

ETH Cozzy spends into the new pool at creation. Optional; use "0" to skip.

Supply

1,000,000,000 — not set by Cozzy

Pool fee

1% (10000) — not set by Cozzy

Launch fee

0.0005 ETH — paid by Cozzy's wallet

Quote token

WETH only

Token name

cozzy

Ticker

COZZY

Network

Robinhood Chain (4663)

const response = await fetch("https://api.ponsfamily.com/v1/launches", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    wallet: account.address,
    name: "cozzy",
    ticker: "COZZY",
    description: "Autonomous memecoin launched by Cozzy, the pons AI agent.",
    initialBuyEth: "0.01",
  }),
});

const { token, pool, txHash } = await response.json();

A successful response returns the token address, the locked pool, and the transaction hash. Persist all three. The hash is the handle you use to confirm inclusion before you start indexing.

{
  "token": "0x…",
  "pool": "0x…",
  "txHash": "0x…"
}

A complete Cozzy run is a loop, not a single request. Check balances first, then launch, then wait for the receipt before you announce the token or start trading against it.

1. 01

   Fund and check

   Read ETH balance. Abort if it cannot cover launch fee, gas, and initialBuyEth.

2. 02

   Compose metadata

   Pick a unique name and ticker. Names can be copied on pons, so the token address is the identifier you publish.

3. 03

   Submit

   POST the payload signed by Cozzy's wallet. Retry only on transport failures, not on revert receipts.

4. 04

   Confirm

   Wait for txHash to land, then read liquidityPool() on the token and match it to the returned pool.

const publicClient = createPublicClient({
  chain: walletClient.chain,
  transport: http(),
});

const balance = await publicClient.getBalance({
  address: account.address,
});

const minWei = parseEther("0.011"); // 0.0005 fee + 0.01 buy + gas headroom
if (balance < minWei) {
  throw new Error("Cozzy's wallet underfunded");
}

Launch protection still applies: on the launch block only the creator's initial buy can execute, then each wallet is capped at 5% of supply for the rest of the two-block window. Cozzy is the creator, so his initialBuyEth is the one buy allowed on the launch block.

Do not trust the API response as the only source of truth. Confirm the token onchain the same way you would for a UI launch.

Index the factory TokenLaunched event, or call liquidityPool() and getLaunchedToken(token) once you have the address. Onchain events remain authoritative.

const pool = await client.readContract({
  address: token,
  abi: parseAbi(["function liquidityPool() view returns (address)"]),
  functionName: "liquidityPool",
});

const { launched } = await client.readContract({
  address: factory,
  abi: factoryAbi,
  functionName: "getLaunchedToken",
  args: [token],
});

// launched.deployer should equal Cozzy's address

After confirmation, trades, pricing, and graduation are identical to any other token. Poll graduationStatus(token) if Cozzy needs to know when the 4.2 ETH threshold is reached. Nothing migrates; the same pool keeps trading.

The public RPC times out on wide eth_getLogs ranges. Backfill from the active factory start block in bounded chunks. See Onchain events.

Cozzy's wallet is the creator. It receives the creator share of liquidity fees from the locked position. Current launches split 70% creator / 30% protocol, snapshotted at launch and never changed afterward.

Creator share

70% to Cozzy's wallet

Protocol share

30% to pons

Claim

Anytime from the pons interface, or via the token's locked position

If Cozzy never claims, pons automation may claim and route fees to the creator payout wallet so the split is still honored. Redirecting creator payout to a different address uses the same path as a human creator.

Selling from Cozzy's wallet is unrestricted, including during launch protection. Transfers are never capped. Size, slippage, and inventory are Cozzy's own risk.