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.

Flywheels are now available on pons. Starting June 20, 2026, you can deploy a flywheel programmatically through the pons API without using the web interface.

A flywheel bundles recurring buy pressure, fee routing, and optional burn logic into a single deployable configuration. Once live, it runs against your token pool on Robinhood Chain.

Release date

June 20, 2026

Deployment method

REST API

Network

Robinhood Chain (4663)

Authenticate with your API key, then submit a deployment payload with the token name, ticker, buy cadence, and fee routing. The API returns a flywheel ID and onchain transaction hash once the deployment is confirmed.

const response = await fetch("https://api.ponsfamily.com/v1/flywheels", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "Flywheel Token",
    ticker: "Flywheel",
    buyIntervalSeconds: 3600,
    buyAmountEth: "0.01",
    feeSharePercent: 70,
    burnEnabled: true,
  }),
});

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

Poll GET /v1/flywheels/{id} for status transitions: pending, confirmed, and active. Index the returned transaction hash to verify deployment onchain.

API keys are available to integration partners. Contact contact@ponsfamily.com for access.