@parabolicfamily/mcp 0.1.7 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Parabolic MCP server
 
-A small [Model Context Protocol](https://modelcontextprotocol.io) server for **Parabolic**, the dollar-native token launchpad on Arc. It lets AI agents (Claude Code, Cursor, custom ERC-8004 agents) discover coins, quote curve trades with the contract's exact math, and build **unsigned** transactions, without a browser.
+A small [Model Context Protocol](https://modelcontextprotocol.io) server for **Parabolic**, a bonding-curve token launchpad on Arc and Robinhood Chain. It lets AI agents (Claude Code, Cursor, custom ERC-8004 agents) discover coins, quote curve trades with the contract's exact math, and build **unsigned** transactions, without a browser.
 
 **What it never does:** hold keys, sign, send or broadcast transactions, custody funds, or accept private keys, seed phrases or session tokens as input. Every `build_*` tool returns `{ to, data, value, chainId }` for the caller's own wallet to sign. Quotes are read from chain at call time and can move before a transaction lands.
 
@@ -14,6 +14,52 @@ npx -y @parabolicfamily/mcp        # starts the server on stdio
 
 The ABIs ship with the package, so it works offline against any Arc RPC you point it at.
 
+## What changed in 0.1.8
+
+One tool, `parabolic.check_ticker`, and nothing else moved: every call that worked in 0.1.7 works unchanged.
+Given a ticker it asks the Parabolic site whether a coin already carries it on **any** chain the site serves
+and whether `<ticker>.parabolic.family` is free. It is advice and not a gate — nothing on chain enforces a
+unique symbol — and the hostname is the one exclusive thing, held by the oldest coin with that ticker. The
+ticker is normalised the way the site normalises it, so an impossible one is refused before a request is spent.
+
+## What changed in 0.2.0
+
+Five tools for coins made on **other launchpads** (pons on Robinhood Chain, SolonPad on Arc), traded through
+Parabolic's aggregator router; every call that worked in 0.1.9 works unchanged.
+
+- `parabolic.list_venue_coins` reads that launchpad's subgraph when `PARABOLIC_SUBGRAPH_URL_PONS_RHC` (or
+  `..._SOLONPAD_ARC`) is set.
+- `parabolic.quote_routed_buy` / `quote_routed_sell` and `build_routed_buy_tx` / `build_routed_sell_tx` encode
+  `ParabolicAggregatorRouter.buy` / `sell` byte for byte as the site does, with no fee voucher and, for an ERC-20
+  input, an exact-amount approval of the router in place of the site's Permit2 signature. The coin lives on the
+  other launchpad's contracts; the router charges Parabolic's routed fee (its `defaultFeeBps`, 60 bps at deploy)
+  on top of that launchpad's own, and every answer shows both.
+- They refuse, by name, until the chain's deployment record carries the router under `aggregator`, when the
+  router has the launchpad switched off, when the coin is not that launchpad's, and when any read fails.
+
+## What changed in 0.1.9
+
+0.1.9 makes **Robinhood Chain (4663) a chain this server serves**. Every call that worked before works
+unchanged and means the same chain it meant: an unqualified address is still Arc, permanently.
+
+- **Set `PARABOLIC_CHAIN_ID=4663` and nothing else.** The chain's public RPC, its factory and its start
+  block ship with the package, read from the deploy's own record rather than typed in. Until 0.1.9 the
+  server answered `chain: "rhc"` with "Parabolic is not deployed on Robinhood Chain yet", which had been
+  false since 19 September 2026, and an operator who set the chain id got Arc's RPC and no factory.
+- **`list_coins` reaches that board.** One site serves both, and it answers for its own chain when nothing
+  names one, so the listing now names the chain (`?chain=rhc`) the way the Telegram bot does. Arc's URLs
+  are byte-identical to what they have always been, because Arc's prefix is empty.
+- **No routed buy there yet.** The chain deploys `ParabolicRouter`, which takes the referral code and the
+  note as arguments; `ParabolicMemoRouter` is Arc's and the two share no function selector, so this
+  package encodes no routed call on chain 4663. `build_buy_tx` goes straight to the curve and
+  `build_launch_tx` to the factory, which is the same call on every chain. The referral share itself is
+  paid on that chain, credited by the indexer through the same ledger as Arc's memo, so what is missing
+  here is the encoder and not the payout: `parabolic.docs` and the buy payload both say so, and passing
+  `memo` is refused by name rather than by asking for a variable that must stay unset.
+- **`parabolic.docs` states Arc mainnet as live.** It described chain 5042 as "unofficial until Circle
+  publishes it" and Arc's launch fee as 1e18; mainnet has been public since 16 September 2026 and the fee
+  has been 0 since the 19th. The fee is read from the factory and never written down.
+
 ## What changed in 0.1.7 (for an existing consumer: nothing has to)
 
 0.1.7 makes the server chain-aware. **Every call that worked in 0.1.6 works unchanged and means the same
@@ -44,13 +90,13 @@ mainnet by mistake, and `protocol_stats` reports the chain and RPC host the serv
 
 | Variable | Meaning | Default |
 |---|---|---|
-| `PARABOLIC_CHAIN_ID` | 5042002 Arc Testnet, 5042 Arc mainnet | `5042` |
-| `PARABOLIC_RPC_URL` | Arc JSON-RPC endpoint | the public endpoint for the chain id |
+| `PARABOLIC_CHAIN_ID` | 5042 Arc mainnet, 5042002 Arc Testnet, 4663 Robinhood Chain | `5042` |
+| `PARABOLIC_RPC_URL` | JSON-RPC endpoint | the public endpoint for the chain id |
 | `PARABOLIC_FACTORY` | `ParabolicLaunchFactory`: coin lookups and launch transactions | the deployment for the chain id |
-| `PARABOLIC_MEMO_ROUTER` | `ParabolicMemoRouter`: the atomic launch-and-buy and the referral-carrying buy | the deployment for the chain id |
+| `PARABOLIC_MEMO_ROUTER` | `ParabolicMemoRouter`: the atomic launch-and-buy and the referral-carrying buy. Refused on a chain whose record deploys `ParabolicRouter` and no memo router, because the two share no function selector and a routed build against that address would revert | the deployment for the chain id |
 | `PARABOLIC_EURC` | EURC address, only for EURC-quoted coins | the deployment for the chain id |
 | `PARABOLIC_SUBGRAPH_URL` | Subgraph endpoint: richer listings, holders, 24h volume, protocol stats | unset (the public API is used instead) |
-| `PARABOLIC_EXPLORER_URL` | Block explorer the address and transaction links are built from | Arcscan for the chain id; Arc mainnet's host is unconfirmed |
+| `PARABOLIC_EXPLORER_URL` | Block explorer the address and transaction links are built from | the explorer for the chain id |
 | `PARABOLIC_HOOK` | `ParabolicHook` address | read from `factory.memeHook()` |
 | `PARABOLIC_ARC_MEMO` | Arc `Memo` system contract | `0x5294E9927c3306DcBaDb03fe70b92e01cCede505` |
 | `PARABOLIC_AGENT_REGISTRY` | Arc's ERC-8004 `IdentityRegistry`: `agent_status`, `build_register_agent_tx` and the `pair: "Agents"` listing filter | the registry Arc publishes for the chain id (Arc Testnet only, today) |
@@ -58,7 +104,8 @@ mainnet by mistake, and `protocol_stats` reports the chain and RPC host the serv
 | `PARABOLIC_FACTORY_START_BLOCK` | First block of the `TokenLaunched` scan, used only when neither a subgraph nor the API is available | the factory's deployment block |
 
 The API default follows the chain: Arc Testnet reads the testnet site (`https://parabolic-testnet.vercel.app/api/v1`,
-live testnet data), Arc reads `https://www.parabolic.family/api/v1`. Running against a fork or your own
+live testnet data), Arc and Robinhood Chain both read `https://www.parabolic.family/api/v1`, which serves
+both boards and is asked for the right one by name. Running against a fork or your own
 factory: the server skips the site's API automatically whenever `PARABOLIC_FACTORY` differs from the
 built-in address for the chain or `PARABOLIC_RPC_URL` points anywhere but the chain's own endpoint, and
 reads the chain instead. To force that for any other reason, set `PARABOLIC_API_URL=""`.
@@ -69,11 +116,11 @@ with source, before you sign anything:
 
 | Contract | Arc Testnet (5042002) |
 |---|---|
-| `ParabolicLaunchFactory` | [`0x2E06eD99bD7D164458847D186B282B23700b2C63`](https://testnet.arcscan.app/address/0x2E06eD99bD7D164458847D186B282B23700b2C63) |
-| `ParabolicMemoRouter` | [`0x1381567ea31a094e64f6B39Bd880d0b59c48e08F`](https://testnet.arcscan.app/address/0x1381567ea31a094e64f6B39Bd880d0b59c48e08F) |
-| EURC (test token) | [`0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a`](https://testnet.arcscan.app/address/0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a) |
-| Arc `Memo` (system) | [`0x5294E9927c3306DcBaDb03fe70b92e01cCede505`](https://testnet.arcscan.app/address/0x5294E9927c3306DcBaDb03fe70b92e01cCede505) |
-| ERC-8004 `IdentityRegistry` (Arc's) | [`0x8004A818BFB912233c491871b3d84c89A494BD9e`](https://testnet.arcscan.app/address/0x8004A818BFB912233c491871b3d84c89A494BD9e) |
+| `ParabolicLaunchFactory` | [`0x2E06eD99bD7D164458847D186B282B23700b2C63`](https://explorer.testnet.arc.io/address/0x2E06eD99bD7D164458847D186B282B23700b2C63) |
+| `ParabolicMemoRouter` | [`0x1381567ea31a094e64f6B39Bd880d0b59c48e08F`](https://explorer.testnet.arc.io/address/0x1381567ea31a094e64f6B39Bd880d0b59c48e08F) |
+| EURC (test token) | [`0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a`](https://explorer.testnet.arc.io/address/0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a) |
+| Arc `Memo` (system) | [`0x5294E9927c3306DcBaDb03fe70b92e01cCede505`](https://explorer.testnet.arc.io/address/0x5294E9927c3306DcBaDb03fe70b92e01cCede505) |
+| ERC-8004 `IdentityRegistry` (Arc's) | [`0x8004A818BFB912233c491871b3d84c89A494BD9e`](https://explorer.testnet.arc.io/address/0x8004A818BFB912233c491871b3d84c89A494BD9e) |
 
 The identity registry is **Arc's contract, not ours**: Arc deploys it, documents it and can change it.
 It is an ERC-1967 proxy, so the implementation behind that address is upgradeable by Arc. Parabolic only
@@ -84,6 +131,12 @@ Arc mainnet (5042), deployed 16 September 2026 at block 21,105,294: factory
 source verified on Sourcify. Arc has published no identity registry for mainnet, so on chain 5042
 `agent_status` says there is no registry rather than reporting a wallet as unregistered.
 
+Robinhood Chain (4663), deployed 19 September 2026: factory
+`0x25c9cFa179256A29f84b9Fd0DcF7cB2ff24b473d`, quoted in USDG (`0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168`,
+six decimals, Paxos), gas paid in ETH, source verified on Sourcify. Gas there is not a dollar, so a launch
+fee or a balance on that chain is never a figure in dollars, and no identity registry exists. The chain's
+`ParabolicRouter` is deliberately not configured here; see 0.1.9 above.
+
 ### Claude Code
 
 ```sh
@@ -150,12 +203,14 @@ Arguments are strict: a key a tool does not know fails with `Unrecognized key` i
 | `parabolic.agent_status` | `{ address }`. Whether the wallet holds an ERC-8004 agent identity on Arc's `IdentityRegistry` (`balanceOf`), how many it holds, and the registry address and chain. On a chain where Arc has published no registry the answer is that fact, with `registered` and `identities` null. |
 | `parabolic.build_register_agent_tx` | `{ from, metadataURI? }` → unsigned `IdentityRegistry.register(metadataURI)` (no value). The registry mints the ERC-721 identity to the signer, so `from` is the wallet that sends it, and returns the agent id; read it from the `Transfer` log in the receipt. `metadataURI` is a pointer to the agent's metadata stored as `tokenURI` and may be empty. Warns when the wallet already holds an identity. |
 | `parabolic.protocol_stats` | Subgraph totals (launches, graduations, trades, volume, fees, daily series) plus the factory's live launch fee, curve preset, snipe-tax terms and contract addresses. |
+| `parabolic.check_ticker` | `{ ticker }`. Whether a Parabolic coin already carries the ticker on **any** chain the site serves, and whether `<ticker>.parabolic.family` is free, read from the site's own route (`/api/v1/studio/ticker` on `PARABOLIC_API_URL`'s site). **Advice, not a gate**: nothing on chain enforces a unique symbol, so `free: false` lists what exists (`taken[]`, each with a `ref` for `get_coin`) and does not stop a launch. The hostname is the one exclusive thing and belongs to the oldest coin carrying the ticker (`hostFree`). A name on the site's reserved list comes back as `reserved` and is not a coin. The ticker is normalised the way the site does it (A-Z and 0-9, case and punctuation ignored, 2 to 10 characters); one outside that is refused before the site is asked. Call it before `build_launch_tx`. |
 | `parabolic.docs` | The adopted parameters, curve mechanics, verified Arc facts and this server's configuration, as text. |
 
 Every tool above also takes an optional `chain` (see "What changed in 0.1.7"), and every coin argument
 takes a reference: `0x…` for a coin on this server's chain, `rhc:0x…` for one elsewhere. A wallet argument
 (`recipient`, `buyer`, `creator`, `from`, `agent_status`'s `address`) stays a plain address — a wallet is
-the same person on every EVM chain.
+the same person on every EVM chain. `check_ticker` accepts `chain` like the others and its verdict still
+covers every chain the site serves, because a ticker taken elsewhere is a collision the moment a link is shared.
 
 Resources: `parabolic://docs/parameters` (same text as `parabolic.docs`) and `parabolic://coins/{address}` (same JSON as `parabolic.get_coin`; the address may be a reference).
 
@@ -221,6 +276,29 @@ The result is `kind: "register_agent"`: one unsigned `tx` to the registry carryi
 registry mints to `msg.sender`. Once it lands, `parabolic.list_coins` with `pair: "Agents"` keeps the
 coins launched from that wallet, and the site tags them `[ Agent ]`.
 
+Check a ticker before launching under it:
+
+```json
+{ "name": "parabolic.check_ticker", "arguments": { "ticker": "$para" } }
+```
+```json
+{
+  "ticker": "PARA", "asked": "$para",
+  "chain": { "id": 5042, "key": "arc", "name": "Arc" },
+  "scope": "every chain the Parabolic site serves, not only this server's chain",
+  "free": false,
+  "taken": [{ "chain": { "id": 5042, "key": "arc", "name": "Arc" }, "name": "Parabolic", "address": "0x552F…4073", "ref": "0x552F…4073", "page": "https://www.parabolic.family/coin/0x552F…4073" }],
+  "reserved": null,
+  "host": "para.parabolic.family", "hostFree": false,
+  "message": "$PARA already trades on Arc as \"Parabolic\". Nothing on chain stops a second coin using it; para.parabolic.family belongs to the oldest coin carrying the ticker.",
+  "notes": ["Advice, not a gate: …", "…"]
+}
+```
+
+`free: true` comes back with `taken: []` and `hostFree: true`, and a name on the site's reserved list as
+`reserved: { name }`. Nothing here is a lock: the verdict is what the site's board holds at the moment of
+asking, and it lags the site's indexer by however far that is behind.
+
 ## Notes on the mechanics
 
 - Curve math is a port of `ParabolicBondingCurve` / `ParabolicBondingCurveMath` (and of `web/lib/curve.ts`): fee legs are taken off the buy input separately, the constant product is priced on `getReserves()`, and a buy that would take more than `sellableTokens()` is clamped to the last sellable tokens, charged the grossed-up price and refunded the rest; that buy graduates the coin, so give it extra gas. Sells take the fee off the gross quote output and close once the curve is ready to graduate.
@@ -246,6 +324,7 @@ src/
   chain.ts      viem RPC wrapper (batched HTTP) behind a small Rpc interface
   subgraph.ts   GraphQL client and Coin/Protocol shapes
   coins.ts      coin summaries, sorting
+  ticker.ts     check_ticker's rule: the site's normalisation, its verdict shape, the sentence
   config.ts     PARABOLIC_* environment
   abi.ts        loads abi/*.json
   docs.ts       parameters + Arc facts text