@parabolicfamily/mcp 0.1.8 → 0.2.1

package/README.md

@@ -22,6 +22,51 @@ and whether `<ticker>.parabolic.family` is free. It is advice and not a gate —
 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.1
+
+No tool changed. The dependency tree is refreshed (`@modelcontextprotocol/sdk` 1.32.1, and the patched
+`proxy-addr`, `ip-address` and `fast-uri` under it), so `npm audit` on an install reads clean, and a failed RPC
+call now writes the endpoint's host to stderr rather than its whole URL, so a keyed endpoint's key stays out of
+the server's own log as well as out of the answer.
+
+## 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
@@ -52,13 +97,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) |
@@ -66,7 +111,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=""`.
@@ -77,11 +123,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
@@ -92,6 +138,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
@@ -149,16 +201,22 @@ Arguments are strict: a key a tool does not know fails with `Unrecognized key` i
 | Tool | Purpose |
 |---|---|
 | `parabolic.list_coins` | `{ status?: "climbing" \| "graduated", sort?: "trending" \| "new" \| "near_graduation" \| "market_cap", limit?, pair?: "USDC" \| "EURC" \| "Agents" }`. Subgraph when configured, otherwise Parabolic's public read API; a `TokenLaunched` log scan only when both are unavailable. `pair` is the quote asset, except `"Agents"`, which means the coin's creator holds an ERC-8004 identity: that is read from Arc's registry (one `balanceOf` per creator, over the top 100 of the sort) whatever the listing source is. Without a registry for the chain the result sets `pairFilterApplied: false` and the `source` line says the filter did not run. |
-| `parabolic.get_coin` | `{ address }` (token or curve). Name, ticker, creator, curve, status/phase, raised/threshold/progress, price, market cap, holders, pool id, fee terms and 50/30/20 split, snipe-tax window and `currentSnipeTaxBps()`. |
+| `parabolic.get_coin` | `{ address }` (token or curve). Name, ticker, creator, curve, status/phase, raised/threshold/progress, price, market cap, holders, pool id, fee terms and the coin's own split (creator / protocol / buyback as the curve snapshotted them at launch, the buyback leg only while the creator's `buybackEnabled` switch is on), snipe-tax window and `currentSnipeTaxBps()`. |
 | `parabolic.quote_buy` | `{ address, quoteIn, buyer?, slippageBps? }`. Exact curve math on live reserves: fee, creator tax and snipe tax legs, spot vs effective price, price impact, whether the buy graduates the coin, suggested `minTokensOut`. `buyer` checks the snipe-tax exemption. |
 | `parabolic.quote_sell` | `{ address, tokensIn, slippageBps? }`. Gross, fee, creator tax, effective price, price impact, suggested `minQuoteOut`. |
 | `parabolic.build_buy_tx` | `{ address, quoteIn, minTokensOut?, recipient, buyer?, slippageBps?, memo? }` → unsigned `curve.buy(...)` (value = quote on native-USDC curves; an approval step for EURC pairs). `memo: { referral, note? }` returns the memo-routed variant instead (see below). |
 | `parabolic.build_sell_tx` | `{ address, tokensIn, minQuoteOut?, recipient, slippageBps? }` → unsigned ERC-20 approval + `curve.sell(...)`. |
-| `parabolic.build_launch_tx` | `{ name, ticker, image?, description?, socials?, pair?, devBuy?, creatorTaxBps?, creator, buybackEnabled? }`. The `TokenParams` are built exactly like the web Create form (economics pinned with `previewLaunchEconomics`, random salt). With `devBuy` and `PARABOLIC_MEMO_ROUTER` set: one unsigned `ParabolicMemoRouter.launchAndBuy` (value = launch fee + dev buy, `creatorFeeRecipient` zero, `minTokensOut` from the curve math on the launch config; `launchAndBuyWithToken` plus an approval for EURC). Otherwise: unsigned `factory.launchToken(...)` with the launch fee as value and, for a `devBuy`, the follow-up buy calldata to send to the curve from the `TokenLaunched` event. |
+| `parabolic.build_launch_tx` | `{ name, ticker, image?, description?, socials?, pair?, devBuy?, creatorTaxBps?, creator, buybackEnabled? }` (`creatorTaxBps` 0 to 500, the factories' `maxCreatorTaxBps()`). The `TokenParams` are built exactly like the web Create form (economics pinned with `previewLaunchEconomics`, random salt). With `devBuy` and `PARABOLIC_MEMO_ROUTER` set: one unsigned `ParabolicMemoRouter.launchAndBuy` (value = launch fee + dev buy, `creatorFeeRecipient` zero, `minTokensOut` from the curve math on the launch config; `launchAndBuyWithToken` plus an approval for EURC). Otherwise: unsigned `factory.launchToken(...)` with the launch fee as value and, for a `devBuy`, the follow-up buy calldata to send to the curve from the `TokenLaunched` event. |
 | `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.referral_status` | `{ account }`. One wallet's referral payouts on this server's chain, read from the site (`GET /api/v1/referrals/{account}`): per asset, what the indexer has credited, what the latest weekly root publishes, what the referral distributor has paid and what is claimable now, with the `claim(asset, account, cumulative, proof)` arguments when there is a leaf. Read-only; figures are never summed across assets. On a chain with no distributor recorded, referrals are paid by hand and the answer says so. |
+| `parabolic.list_venue_coins` | `{ venue: "pons" \| "solonpad", status?, sort?, limit? }`. Coins made on another launchpad, read from that launchpad's subgraph when `PARABOLIC_SUBGRAPH_URL_<VENUE>_<CHAIN>` is set, with the figures `list_coins` returns plus `venue`, the site's `ref` and whether they can be routed here. They live on that launchpad's contracts, not Parabolic's. |
+| `parabolic.quote_routed_buy` | `{ venue, address, quoteIn, from?, slippageBps? }`. Tokens received for `quoteIn` of the coin's own quote asset, bought through `ParabolicAggregatorRouter` on the launchpad's curve (the router's quote view) or its graduated v4 pool (the chain's V4Quoter), read now, with the launchpad's fee and Parabolic's routed fee (the router's `defaultFeeBps`) both shown. |
+| `parabolic.quote_routed_sell` | `{ venue, address, tokensIn, from?, slippageBps? }`. Money received, after Parabolic's routed fee, for `tokensIn` sold through the router, read now. |
+| `parabolic.build_routed_buy_tx` | `{ venue, address, quoteIn, from, slippageBps?, maxSnipeTaxBps? }` → unsigned `ParabolicAggregatorRouter.buy(trade, noVoucher, "0x", noPermit)`, encoded as the site encodes it: `minOut` from a fresh quote less slippage, recipient = `from`, a five-minute deadline; an ETH-quoted coin sends `quoteIn` as value, a USDG-quoted one returns an exact-amount approval of the router first. Inside a launch window the build is refused and names the tax unless `maxSnipeTaxBps` accepts it. |
+| `parabolic.build_routed_sell_tx` | `{ venue, address, tokensIn, from, slippageBps? }` → unsigned exact-amount approval of the router plus `ParabolicAggregatorRouter.sell(...)`; `minOut` is the money after Parabolic's fee. The four routed tools refuse, by name, until the chain's record carries the router (`aggregator`), when the router has the launchpad off, when the coin is not that launchpad's, and when any read fails. |
 | `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
@@ -207,7 +265,7 @@ Launch a coin with a $200 dev buy:
 { "name": "parabolic.build_launch_tx", "arguments": { "name": "Orange Pill", "ticker": "PILL", "image": "ipfs://…", "description": "a frog", "socials": { "twitter": "@robin" }, "creatorTaxBps": 250, "devBuy": "200", "creator": "0xYourWallet" } }
 ```
 
-With `PARABOLIC_MEMO_ROUTER` set the result is `kind: "launch_and_buy"`: one `tx` to the router (`value` = $1 launch fee + $200), the encoded `params` (`creatorFeeRecipient` zero, as the router requires), the curve `terms` (opening and fully diluted graduation market caps, reserved / pool-seed / locked token shares, snipe-tax window) and `devBuy` (expected and minimum tokens, snipe-tax exempt). Without the router it is `kind: "launch"`: `tx` to the factory (value = the launch fee) and `devBuy` with the calldata for the second, snipe-tax-exempt transaction to the new curve. There is no exemption list: only the creator's own address is exempt from the snipe tax.
+With `PARABOLIC_MEMO_ROUTER` set the result is `kind: "launch_and_buy"`: one `tx` to the router (`value` = the factory's `launchFee()`, 0 on both chains today, + $200), the encoded `params` (`creatorFeeRecipient` zero, as the router requires), the curve `terms` (opening and fully diluted graduation market caps, reserved / pool-seed / locked token shares, snipe-tax window) and `devBuy` (expected and minimum tokens, snipe-tax exempt). Without the router it is `kind: "launch"`: `tx` to the factory (value = the launch fee) and `devBuy` with the calldata for the second, snipe-tax-exempt transaction to the new curve. There is no exemption list: only the creator's own address is exempt from the snipe tax.
 
 Check whether a wallet is a registered agent, then register it:
 
@@ -295,7 +353,7 @@ The source lives in a private repository; the published package ships `src/` alo
 code is readable from `node_modules`. If you have the repository checked out:
 
 ```sh
-npm install          # reads .npmrc (legacy-peer-deps) to skip a vitest peer-resolution bug on Node 23
+npm install
 npm run build        # -> dist/
 npm test             # vitest: curve math, tx builders, tools against a mocked subgraph and RPC
 npm run smoke        # starts dist/index.js over stdio, initialize + tools/list