pons-mcp

The Pons launchpad, from inside your agent.

pons-mcp is a Model Context Protocol server for the Pons launchpad on Robinhood Chain. Point Claude Desktop, Claude Code, or any MCP client at it and ask in plain words: what will 0.01 ETH buy on this curve, is the snipe tax still running, which tokens graduated overnight, how much fee income is sitting in escrow for mine.

Reads work out of the box and need no key. Launching and trading need a key you choose to hand over, and a confirm you type. Install it, or start with what people ask it to do.

Token

There is no contract address yet. When there is one it will be posted here and on the project's X account before anywhere else. Any address you see elsewhere is not ours.

What people ask it to do

These are the questions the tools were built around. Each one is a short conversation, not a form.

"Is 0x892c… a real Pons launch, and what does 0.005 ETH get me right now?"

It checks that the factory actually registered the token, tells you which phase the curve is in, whether the launch-window tax is still decaying for your address, and quotes the buy from the curve math. Then it runs the same quote through eth_call and tells you if the two disagree.

Tools: pons_get_token, pons_snipe_tax, pons_quote_buy

"Launch PIVOT on the default config with a 0.002 ETH opening buy."

You get the economics digest, the exact cost (launch fee plus your opening buy plus gas), the calldata, and a simulation result. Nothing has been sent. Say confirm and it simulates again, signs, and broadcasts. The opening buy is capped at 0.05 ETH unless you raise the cap yourself.

Tools: pons_preview_launch, pons_launch_token

"Who launched in the last hour, and did anyone real buy in?"

Launches come back newest first. The scoring pass counts unique buyers and ETH in per curve, so a launch with forty wallets looks different from one wallet buying itself. Ask about a creator and you get every token they have launched and which ones graduated.

Tools: pons_recent_launches, pons_scan_interesting, pons_creator_launches

"What fees can I claim on my token, and move the recipient to my cold wallet."

Escrow balances in ETH and per token, plus how much of the five-year buyback lock has vested. Claims can be partial. The recipient transfer takes effect the moment it is mined, with no timelock, which is worth knowing before you point it somewhere.

Tools: pons_fee_balances, pons_claim_fees, pons_set_creator_fee_recipient

"It graduated. Sell a quarter of my bag into the V4 pool."

The quote comes from the on-chain V4 quoter with the hook fee included. A sell goes through Permit2, and that permit is only signed when you broadcast, so a dry run never leaves a replayable signature in your chat history.

Tools: pons_quote_swap, pons_swap

"This one is from the old V1 pad. Did it ever graduate?"

The legacy Uniswap V3 generation still has tokens trading. The server reads the V1 factory record, graduation status, and metadata, and can scan its launch history by absolute block range.

Tools: pons_v1_get_token, pons_v1_launches

The tools page lists all of them, grouped the same way.

How a write goes

  1. You see it before it happens. Call a write tool and you get a simulation of each step through eth_call, a gas estimate, the total cost, and the exact calldata. The simulation uses balance overrides, so a wallet with nothing in it still exercises the real contract logic. Nothing is signed.
  2. Then you confirm. Call again with dryRun=false and confirm=true. Both are strict booleans; the string "false" does not count. The server simulates once more, refuses if any step reverts, signs, and sends the steps in order, waiting for each receipt before the next.

A token's life on Pons

The server reports whichever phase the chain says a token is in. It never infers one. The phases are numbered as they are in the contract.

  1. NotGraduated. Trading on the token's own bonding curve. Buys and sells, a 1% curve fee, and a 99% snipe tax that decays to zero over the first three seconds.
  2. Swept. Once the curve raises its threshold (4.2 ETH on the default config) sells stop. Anyone can call graduate, and the curve drains into the factory.
  3. PoolCreated. A Uniswap V4 pool is seeded behind the Pons hook and the position is locked. From here on, trading is a V4 swap.
  4. Rescued. If graduation fails, the owner can rescue after a seven-day delay.

Read-only until you hand it a key

Leave PONS_PRIVATE_KEY unset and the write tools are never registered. Your MCP client cannot list them, so it cannot call them. The only RPC methods in play are reads, and the worst outcome is a wrong answer.

Set a key and the server can spend whatever that wallet holds. Use a fresh wallet funded with only what you mean to spend. The key is read from the environment once, deleted from process.env, and never written to a log. Only the derived address ever appears. The security page goes through the caps and checks in detail.

Why there is no web3 framework in it

Robinhood Chain is young and its tooling lags. viem 2.56.3 silently dropped topic filters on this chain, which is the kind of bug that makes a launch scanner return the wrong tokens with no error. So the server speaks raw JSON-RPC over fetch, encodes ABI and RLP by hand, and re-filters every log it receives: the address and every topic position must match or the log is dropped.

Where the Pons docs and the chain disagree, the chain wins. The docs said the snipe-tax window was five seconds. The contract says three. The server says three. Every selector and event topic is recomputed from its signature at startup and compared to a pinned constant; if they differ the process exits rather than send calldata that no longer matches the contract.

Runtime dependencies are the MCP SDK, zod, and the noble hashing and curves libraries. Node 20 or newer.