@arcnow/mcp
OfficialThis server lets an AI assistant read and—only when the operator explicitly enables it—trade tokens on arcnow.io across Arc mainnet and testnet.
Read-only by default: inspect network, chain, contracts, graduation venues, server mode, and spend caps (
arcnow_network).Explore launch quotes: list quote tokens a launch may use, with fees, acceptance status, and spend caps (
arcnow_quote_tokens).List recent token launches from on-chain logs, with optional creator filter and live curve state (
arcnow_list_tokens).Inspect any token: metadata, quote token, bonding-curve parameters and state, price, graduation progress, and whether it trades on its curve, in a Uniswap v4 pool, or nowhere (
arcnow_token).Quote trades without spending: get tokens out, full fee breakdowns (curve 1% split four ways; pool 0.80% hook + 0.20% LP fee), average fill price, slippage floors, and price impact for buys and sells (
arcnow_quote_buy,arcnow_quote_sell).Quote a launch: see exact cost, initial buy, trade fee, and predicted token/curve addresses before committing (
arcnow_quote_launch).Inspect platforms: fee splits, default migrators, curve templates, and the full registry enumeration (
arcnow_platform,arcnow_list_platforms).Write only with explicit opt-in and a key: launch tokens, buy, sell (with controlled router approval in pools), migrate graduated curves, withdraw stranded refunds, and register platforms (
arcnow_launch,arcnow_buy,arcnow_sell,arcnow_migrate,arcnow_withdraw_refund,arcnow_register_platform).Safety guarantees: no credentials are ever tool arguments, schemas are strict, spend caps are per quote token and fail closed, and every spending call requires an explicit
maxTotalCostand slippage setting.
Provides tools for interacting with arcnow.io on Arc, enabling reading of bonding curves, quoting trades, checking token graduation progress, and optionally launching, buying, selling, and rescuing token migrations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@arcnow/mcp How close is the token 0x1234abcd to graduating on Arc?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@arcnow/mcp
An MCP server that lets an AI assistant use arcnow.io on Arc: read the bonding curves, quote a trade with its full fee breakdown — on a token's curve before it graduates, or in its Uniswap v4 pool after — see how close a token is to graduating, and, only if the operator explicitly turns it on, launch, buy, sell and rescue a stranded migration.
Every chain interaction goes through
@arcnow/sdk, pinned to an exact
published version in pins.json. Nothing here encodes a call or
computes a curve.
Install and run
The server is on npm as @arcnow/mcp
(Node 22.12 or newer). Run it straight from the registry:
npx -y @arcnow/mcp # read-only. The default, and the useful part.
npx -y @arcnow/mcp --allow-writes # can spend, if ARCNOW_PRIVATE_KEY is in the environment.Every client below runs that same command with ARCNOW_MCP_NETWORK set. The
examples say arc-mainnet, where arcnow.io is live — Arc
mainnet, chain 5042. arc-testnet is the rehearsal network: the same contracts
at other addresses, with test funds. With the variable unset the server starts
on arc-testnet, so nobody is pointed at real money by omission.
Write mode, in every client: add --allow-writes to the arguments and put
the signing key in a file the server reads through ARCNOW_PRIVATE_KEY_FILE
— never the key itself in a client config, which gets committed and
screenshotted. Read-only needs no key at all. On arc-mainnet every write is
real money: the spend caps below are what bounds a mistake, and the server
says so at startup and in every session. Every variable is in
Configuration; examples/ has both shapes — the
writes-enabled one on arc-testnet, as a rehearsal.
Claude Code
claude mcp add --env ARCNOW_MCP_NETWORK=arc-mainnet --scope user arcnow -- npx -y @arcnow/mcp--scope is local (this project, you only; the default), project (checked
into .mcp.json at the project root, shared with the team) or user (every
project). The project-file form:
{
"mcpServers": {
"arcnow": {
"command": "npx",
"args": ["-y", "@arcnow/mcp"],
"env": { "ARCNOW_MCP_NETWORK": "arc-mainnet" }
}
}
}Claude Desktop
claude_desktop_config.json — macOS
~/Library/Application Support/Claude/claude_desktop_config.json, Windows
%APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"arcnow": {
"command": "npx",
"args": ["-y", "@arcnow/mcp"],
"env": { "ARCNOW_MCP_NETWORK": "arc-mainnet" }
}
}
}Codex
~/.codex/config.toml (or .codex/config.toml in a project):
[mcp_servers.arcnow]
command = "npx"
args = ["-y", "@arcnow/mcp"]
[mcp_servers.arcnow.env]
ARCNOW_MCP_NETWORK = "arc-mainnet"Or from the CLI: codex mcp add arcnow --env ARCNOW_MCP_NETWORK=arc-mainnet -- npx -y @arcnow/mcp.
Cursor
.cursor/mcp.json in the project (or ~/.cursor/mcp.json for every project):
{
"mcpServers": {
"arcnow": {
"command": "npx",
"args": ["-y", "@arcnow/mcp"],
"env": { "ARCNOW_MCP_NETWORK": "arc-mainnet" }
}
}
}VS Code (Copilot agent mode)
.vscode/mcp.json — note the key is servers, not mcpServers:
{
"servers": {
"arcnow": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@arcnow/mcp"],
"env": { "ARCNOW_MCP_NETWORK": "arc-mainnet" }
}
}
}For write mode, VS Code's inputs can prompt for the key-file path instead of
writing it into the file; see its MCP documentation for the ${input:…} form.
Gemini CLI
~/.gemini/settings.json (or .gemini/settings.json in a project):
{
"mcpServers": {
"arcnow": {
"command": "npx",
"args": ["-y", "@arcnow/mcp"],
"env": { "ARCNOW_MCP_NETWORK": "arc-mainnet" }
}
}
}Or gemini mcp add -e ARCNOW_MCP_NETWORK=arc-mainnet arcnow npx -y @arcnow/mcp.
Windsurf, Cline
Both take the generic mcpServers JSON above — the same command, args and
env — in their MCP settings file.
From source
Clone arcnow-io/arcnow-io-mcp, then
npm ci && npm run build && node dist/index.js; the SDK comes from npm.
Related MCP server: Arcade Agent MCP
The two rules this server is built around
1. A private key is never a tool argument
No tool here takes a key, a mnemonic or a credential of any kind. The signing
key is read once, at startup, from ARCNOW_PRIVATE_KEY or a file named by
ARCNOW_PRIVATE_KEY_FILE, and from nowhere else.
This is not a claim about environment variables being safer in general. It is about where a tool argument goes. An argument is written by a model into a transcript: to the model provider, into the client's logs, into the context of every later turn, and into the bug report somebody pastes into an issue. A key that has been through a tool call has been published, and there is no un-publishing it.
So the schemas declare no such field, and — because declaring nothing is not
enough — every schema is strict. An argument this server did not ask for is
a refusal, not a silently dropped key, and if the field was named like a
credential the refusal says so and says to rotate it. test/unit/no-key-arguments.test.ts
walks every published schema and asserts both halves.
2. Read-only is the default, and writing is the operator's decision
With an empty environment this server can read everything and spend nothing. The
write tools are not published at all: a model that cannot see arcnow_launch
does not offer to launch anything.
Writing requires --allow-writes (or ARCNOW_MCP_ALLOW_WRITES=1) and a key,
from whoever starts the process — a person editing a config file, not a model
mid-conversation. The mode is printed on stderr at startup and reported by
arcnow_network, so nobody has to guess which one they are talking to.
Two edge cases, both deliberate:
A key with no opt-in starts read-only and warns that the key is present and unused. A key is not consent to spend it.
An opt-in with no key refuses to start. The operator asked for something this process cannot do, and a server that quietly downgrades produces its failure later, in the middle of somebody's trade.
The tools, and why each one exists
Nine read tools, always published. Six write tools, published only on opt-in.
Read
tool | what it answers |
| Which chain, which contracts, which graduation venues, whether a v4 router is configured for graduated tokens, and which mode this server is in. The first call of any session that might trade. |
| The quote tokens a launch may use — native USDC and the ERC-20s the quote registry allowlists, such as EURC — each with its symbol, name, decimals, address, whether it is native, its launch fee in its own units (zero on both networks: launching is free, and the figure is read from the registry rather than assumed), whether the registry accepts it now, and this server's spend cap for it. At most three |
| Recent launches, newest first, from the launchpad's |
| One token in full: metadata, its quote token (address, symbol, decimals, native or ERC-20), its curve's parameters ( |
| What an amount of the token's quote ( |
| The same for a sell — plus, on a curve, that selling needs no approval, ever, and in a pool, that it does, and how much the holder has approved already. |
| What a launch in a given |
| A platform's four-way fee split, its default migrator and its curve template — every share printed both as bps of the fee and as a percentage of a trade. |
| The registry's actual enumeration. Complete, unlike the token list. |
The read tools are the valuable part. An assistant that can answer what is this token, what would 50 EURC buy me, how close is it to graduating with no key anywhere near it is useful to far more people than one that can trade.
Three things the read tools go out of their way to say, because each is a mistake that costs money:
A spot price is not a fill price. The curve integrates price across an order, so a buyer pays a rising price over their own trade. Every quote reports an average fill price next to the spot price, and the tool descriptions tell the model to quote rather than multiply.
A share of the fee is not a share of the trade. 3000 bps of the fee is 0.30% of a trade. Both are printed, every time. The fee has four parties — creator, platform, referrer, protocol; arcnow.io's own split is 3000 / 3500 / 1000 / 2500 — and no developer share: no tool takes a
developer.Graduated and migrated are different states. A curve can have stopped trading permanently while its pool was never created, and then the token trades nowhere. That is reported as its own thing, with the rescue named.
A pool quote is not a curve quote. It says so, and it names two charges, not one: the fee hook's 0.80%, taken in the pool's quote and split creator / platform / protocol, and the pool's own 0.20% Uniswap LP fee — 1.00% in all, the same as the curve charged. Both rates are read off the pool, never assumed.
Write
tool | what it does | irreversible? |
| Launches a token and its curve, priced for life in the | Yes, in every respect. |
| Buys wherever the token trades — its curve, or its v4 pool once migrated. Spends | No — the tokens can be sold back, at a price. |
| Sells wherever the token trades. Receives the token's quote. In a pool, grants the router an approval only when told to, for exactly the amount sold. | No |
| Creates the pool for a curve that graduated without one. | No — it only ever adds a market. |
| Claims the quote a curve credited after a failed transfer. | No — it recovers funds. |
| Deploys a new | The config is permanent. |
arcnow_launch's description says, in as many words, that the name, symbol,
supply, curve shape and graduation venue are fixed at that transaction and can
never be changed by anyone, that there is no admin key that can fix a typo in a
symbol, and that the only remedy is another launch and another fee. It also
requires acknowledgeIrreversible: true, which is not security — a model can
set a boolean — but does make the assertion explicit in the transcript.
How a write is gated, in order
The operator's opt-in. Not published, and refused by name if called anyway. (A cached tool list is why the refusal exists as well as the omission; "unknown tool" reads as "you guessed wrong" and invites a model to try variations.)
The operator's ceilings, one per quote token. See spend caps. Not arguments, and they cannot be raised from a tool call.
The caller's stated ceiling. Every spending tool requires
maxTotalCost, in the token's quote: the most the caller believes this call will cost. A fresh quote is taken inside the call and compared against it. That catches a quote that went stale between being shown to a person and being acted on, a curve that moved, and a model talked into a bigger number than the conversation agreed to — none of which one session-wide ceiling catches.No default slippage.
slippageBpsis required on every trading tool. Zero means "fill me at any price", which on a public mempool is a donation, so it has to be typed rather than omitted.Nothing that does not apply. A curve trade pays the sender and has no
recipient; a pool swap has noreferrerand cannot graduate anything, sogasLimitguards nothing there. Each is refused on the venue it does not exist on, before anything is quoted or sent — never silently dropped. The SDK refuses the same things; this server says so first.The report. Each tool states the exact cost and the exact effect, and says afterwards what actually happened.
None of that makes an assistant trustworthy with money. It makes the blast radius a number somebody chose.
The gas trap, which this server handles for you
A graduating buy migrates the curve in its own transaction, under a bounded
gas budget whose failure the curve catches rather than reverting. So
eth_estimateGas — which searches for the lowest limit at which the transaction
still succeeds, and a graduating buy succeeds either way — converges on exactly
the limit at which the migration is starved. The buy fills, the curve graduates,
the refund is correct, and the pool is simply never created. There is no revert
and no error anywhere.
arcnow_buy therefore takes a fresh quote, and when that quote says the buy
graduates it sends an explicit 8,000,000 gas limit rather than letting the
node estimate one. (The curve budgets 6,000,000 for the migrator and keeps
100,000 back; a limit is a ceiling, not a charge.) A gasLimit below 6,200,000
on a graduating buy is refused outright. The result reports
migratedInThisTransaction, which is a different question from whether the
curve graduated — and when the migration was starved anyway, it names
arcnow_migrate as the permissionless rescue.
Trading a graduated token
A token's market moves once, irreversibly: from its bonding curve to a Uniswap
v4 pool, when the curve graduates and migrates. The quote and trade tools go
through the SDK's client.trade(token), which decides the venue, so the same
four tools work across that line. Three states, told apart out loud:
state | quote | buy / sell |
on its curve | a curve quote, as before | through the curve; |
graduated and migrated | a pool quote, labelled as one | through arcnow.io's router; |
graduated, not migrated | refused: tradeable nowhere until | refused, naming |
What a pool quote contains. The SDK prices a pool trade by simulating the
real swap through the router, so the figures are the real fill with two charges
inside them. The quote takes them back out and names each: the fee hook's 0.80%,
which it takes in the pool's quote and splits creator 5000 / platform 1875 /
protocol 3125 bps (a pool swap has no referrer), and the pool's own 0.20% LP fee
— the pool key's fee, in hundredths of a bip — which Uniswap charges and the
pool's liquidity keeps. 1.00% in all, the same as the curve. Every rate comes
from the SDK's Pool.fees(), which reads the hook's feeBps() and
feeConfigOf() and the key; this server holds no fee constant, so a pool whose
key carries another LP fee is reported at the fee it carries. It shows the
average fill price, the pool's spot price, and the price impact between them.
The SDK has no
reader for a pool's price, so the spot price is the SDK's own quote of a
probe buy with both fees taken out — 0.000001 of an 18-decimal quote, or 10,000 raw
units of a smaller one (0.01 EURC), so the fees' raw-unit rounding stays below one
part in ten thousand — and the report says so.
The pool's quote is the SDK's. A v4 key orders its currencies by address:
native USDC is always currency0, an ERC-20 such as EURC can be either.
Nothing here reads currency0 as the quote; arcnow_token says which currency
of the key the SDK found the quote to be.
The sell approval. A curve sell needs no approval; a pool sell does, because
the router pulls the tokens with transferFrom. That approval is a separate
transaction granting spending rights, and it is the one thing this server does
that grants rights rather than spending money. So arcnow_sell:
never sends it unless the call says
approveRouter: true. Without it, a sell whose allowance is short is refused, nothing is sent, and the refusal says exactly what the approval would be: token, owner, spender, amount;approves exactly the amount being sold, never an unlimited allowance, and only if the existing allowance does not already cover the sale;
reports it — token, owner, spender, amount, transaction, and the allowance left afterwards — including when the sell that followed it then failed, in which case it says the approval still stands.
approveRouter on a curve sell is refused: nothing would use it.
A revert inside the pool. Uniswap v4 wraps a revert from inside a hook, and
a failed transfer out of the PoolManager, in WrappedError (0x90bfb865). The
SDK unwraps it: a known inner error keeps its own code with the wrapper layers on
details.wrappedBy, and an empty one is WrappedRevert, with each layer named
— NativeTransferFailed or ERC20TransferFailed for a transfer. This
server names the failed transfer from the decoded layers, points at
arcnow_quote_buy for a smaller amount, and shows the SDK's reason and the layers
once. It adds no cause of its own.
How a failure is said. A code the SDK raises itself (SDK_ERROR_CODES) is a
refusal made before any transaction — AddressIsNotACurve,
UnknownCurveVersion, UnknownHookVersion and the rest. A
decoded contract error or revert failed on-chain. RpcFailure could not
reach the chain: the public endpoint rate-limits, and that says nothing about
the token.
One curve, on two networks
arcnow.io has one bonding curve — the constant-product curve,
arcnow/bonding-curve@4.x.x, priced in a quote token, with parameters r0Wad
(the virtual quote reserve at launch, in WAD) and y0Wad (the virtual token
reserve at launch) — launched through one contract stack, and a fee hook,
arcnow/arc-now-fee-hook@4.x.x, that takes its 0.80% in the pool, accrues each
fee as a PoolManager claim and pays it out at the start of a later swap. The same
build is live on Arc mainnet (arc-mainnet) and Arc testnet (arc-testnet), at
different addresses; a token address from one means nothing on the other, and
the server's instructions say which network a session is on.
Nothing a tool prints names a curve kind or a stack. There is one of each.
arcnow_tokenprints the curve's own parameters, and a pool trade reports the fees it paid out from earlier trades (FeesDistributed) apart from the trader's fill.Any other version is refused by name, and never priced. A curve or a platform of another version — the retired multi-quote stack,
@3.x.x, which carried a developer share and whose data was wiped; the@2.x.xcontracts before it; the retired linear curve,@1.x.x— is the SDK'sUnknownCurveVersion, naming the version, before any quote or send. A fee hook of another version — the@3.x.xhook that charged 1% in the pool included — isUnknownHookVersion, and neither its accrual nor its rates are read.An address that is not a curve is refused by name. The SDK's
AddressIsNotACurvefor an arcnow.io token's address is followed to its curve; for anything else — an ordinary ERC-20, an account, nothing at all — it is the refusal, saying the address is not an arcnow.io token either.arcnow_list_tokensreads the one launchpad, back to the block its stack was deployed in (21,179,866 on Arc mainnet, 62,386,232 on Arc testnet).
Configuration
Everything is an environment variable, because an MCP client's config file is
where an operator's decisions belong. See
examples/ for a read-only and a writes-enabled client config.
variable | default | what it does |
|
| The network preset: |
| unset | A path to a JSON document in the SDK's |
| the preset's endpoint | Override the endpoint. Redacted of credentials before it is ever printed. |
| unset |
|
| unset | The signing key. Read once, at startup. Never printed, never serialised, never a tool argument. |
| unset | The same, from a file — so the key is not in the client's config file either. Setting both is an error rather than a guess. |
|
| The ceiling on any single write call spending native USDC, in whole USDC. |
| unset: refused | The ceiling on any single write call spending that quote token, in its own units: |
|
| Block range per |
|
| How many such requests one |
There is no secret anywhere in this repository, and nothing here writes one to
disk. ARCNOW_PRIVATE_KEY_FILE is the recommended shape: a client config that
names a path holds no key even when it is committed or screenshotted.
Spend caps: per quote token, fail-closed
A token is priced in one quote for life, and a cap in USDC cannot bound a spend in EURC. So every quote token has its own cap, in its own units:
ARCNOW_MCP_MAX_SPEND_USDCcaps native USDC, and defaults to100.ARCNOW_MCP_MAX_SPEND_<SYMBOL>caps each other quote —ARCNOW_MCP_MAX_SPEND_EURC=50is 50 EURC. The symbol is upper-cased; a character that is not a letter or a digit is written_. The cap is matched to the network's own token by address: onarc-mainnetthat is EURC at0xbEf5f6d5…, onarc-testnetat0x89b50855…, each read from the preset.
It fails closed, four ways:
A quote with no cap is refused for every spending write —
arcnow_launchandarcnow_buy— with a refusal that names the variable to set. Non-native quotes have no default. A cap can never be got round by switching quote.A symbol resolves only against the network's own
quoteTokens— the SDK'snetworks.json, orARCNOW_MCP_NETWORK_FILE— and a cap is matched to a token by address. A token's on-chainsymbol()is never consulted, so a token calling itself EURC does not get EURC's cap, and a quote the network does not list can have no cap at all: it is always refused.A
ARCNOW_MCP_MAX_SPEND_…variable that names no quote token of the network refuses to start the server, which catches a typo such as…_EURO.Two quote tokens of the network sharing a symbol refuses to start it: one variable cannot mean two caps.
What counts: a launch spends its totalCost — the initial buy plus any launch
fee (zero on both networks), in the launch's quote; a buy spends its quoteIn. For an ERC-20 quote the
SDK approves exactly that spend, so the same check covers the approve. The
caller's own maxTotalCost is read in the same quote. The startup banner,
arcnow_network and arcnow_quote_tokens show every cap, and
describe() reports maxSpendPerCallUsdc and maxSpendPerCall
({ "USDC": "100", "EURC": "50" }, or null where none is set).
A network the SDK has no preset for
ARCNOW_MCP_NETWORK_FILE=/path/to/network.json points the server at a
deployment by its addresses — a local anvil stack, or the stack this
repository's fork proof deploys onto a fork of Arc testnet:
{
"name": "arc-testnet-fork",
"rpcUrl": "http://127.0.0.1:8545",
"chainId": 5042002,
"contracts": { "launchpad": "0x…", "tokenFactory": "0x…", "curveFactory": "0x…",
"migratorRegistry": "0x…", "platformRegistry": "0x…",
"arcnowPlatform": "0x…", "quoteRegistry": "0x…",
"v4Migrator": "0x…", "feeHook": "0x…", "v4Router": "0x…" },
"v4": { "poolManager": "0x…" },
"quoteTokens": [
{ "address": "0x0000000000000000000000000000000000000000", "symbol": "USDC", "name": "USD Coin", "decimals": 18, "isNative": true },
{ "address": "0x89b50855aa3be2f677cd6303cec089b5f319d72a", "symbol": "EURC", "name": "EURC", "decimals": 6, "isNative": false }
],
"quoteAllowanceSlots": { "0x89b50855aa3be2f677cd6303cec089b5f319d72a": 10 }
}It is validated by the SDK's own resolveNetwork: a missing required contract,
an invalid quote token or unreadable JSON stops the server at startup.
quoteAllowanceSlots may be numbers or decimal strings. ARCNOW_RPC_URL still
overrides the endpoint. Setting it together with ARCNOW_MCP_NETWORK or
--network= is an error, not a guess.
Amounts are decimal strings
"25", "1.5" — never JSON numbers. A JSON number is an IEEE double, and a
double cannot hold 0.000193050193050194 (the shipped curve's last price) or
any 18-decimal quantity above about nine million.
Every amount is in the token's own quote, parsed exactly in that quote's
decimals. quoteIn, initialBuy and maxTotalCost are read with the SDK's
QuoteAmount.parse in the decimals of the quote they are in — 18 for native
USDC, 6 for EURC — so "1.0000001" of EURC is refused, naming the decimals,
rather than rounded to an amount nobody typed. Nothing this server prints is a
bare number: money is always 123.75 USDC or 1.5 EURC, in the symbol of the
quote it is actually in.
On Arc, native USDC is the gas currency, at 18 decimals. The USDC ERC-20 predeploy is the same asset reporting 6; it pays for nothing and is not a quote token. Gas is always native USDC, whatever a token's quote.
The SDK, and how the pin works
@arcnow/sdk is published to npm from
arcnow-io/arcnow-io-sdk, one tagged
release per version, and this server depends on it at an exact version —
"@arcnow/sdk": "0.2.0", never ^0.2.0. The tool descriptions promise what one
known SDK does; a range would let npm install move the code under them with no
commit here saying so. Moving the pin is a pull request.
pins.json records it:
"sdk": {
"package": "@arcnow/sdk",
"version": "0.2.0",
"integrity": "sha512-…",
"public_repo": "arcnow-io/arcnow-io-sdk",
"tag": "v0.2.0",
"why": ["what this server uses from that SDK, in prose"]
}integrity is the sha512 of that version's tarball, as npm records it in
package-lock.json and serves it as dist.integrity. The tarball is the
surface: every module, the generated ABIs that encode every call, the
networks.json every address comes from — one hash. (Until the SDK was
published this file hashed its sources file by file and the gate recompiled its
dist/; the integrity replaces all of that.)
Before every release the maintainers verify that the manifest, the lockfile, the installed package and the registry all name that one tarball; moving the pin is a pull request that reads the SDK's changelog and re-reads every tool description.
Testing
npm test # the unit suite: no chain, no container, no keyIt runs against a fake chain that does exactly what each test says, and proves what can be proved offline:
A key is never an argument. Every published schema is walked for credential-shaped field names and asserted strict; passing
privateKeyormnemonicanyway is refused, named, answered with "rotate it", and sends nothing.A write refuses without the opt-in, names
--allow-writesandARCNOW_PRIVATE_KEY, and has sent nothing.Both spend ceilings stop a transaction, on a curve and in a pool, per quote token, on either preset — mainnet's EURC is capped by its mainnet address; a typo'd cap variable refuses to start; a USDC cap does not apply to EURC or the reverse.
Every amount is labelled with its own quote, an input with more decimals than its quote is refused, and an ERC-20 approve is reported whether it was sent or not.
The gas trap is handled, the venues are told apart (a stranded token is refused everywhere with
arcnow_migratenamed), the sell approval is never sent withoutapproveRouter: trueand never for more than the amount sold, and the reports say true things: a curve fee broken out four ways, a pool's 0.80% and 0.20% read off the pool and never assumed, a free launch printed from the registry's zero, average fill price apart from spot, graduated apart from migrated.Both presets resolve to the SDK's live deployments,
arc-mainnetsays it is real money, and nothing of one network's addresses appears in a report about the other.The wire works: a real MCP client against a real MCP server over an in-memory transport.
What the unit suite cannot prove — that the built server, driven by a real MCP client over stdio, lists the quote tokens, launches, buys and sells a token on its curve and in its Uniswap v4 pool, and launches and buys a token priced in EURC under the EURC cap, against arcnow.io's real contracts, every quote equal to its fill to the wei — the maintainers prove before every release, on an anvil fork of Arc testnet with those contracts deployed onto it. A fork re-executes with anvil's EVM, so Arc's own execution semantics are outside even that; and no test can prove that a tool description is true or that a model behaves — every guard here is a bound on damage, not a guarantee of judgement.
Licence
GPL-3.0-or-later, the same licence as @arcnow/sdk, which this server builds on. See LICENSE.
Available Tools
9 toolsarcnow_list_platformsList registered platformsARead-onlyIdempotent
Every platform the registry has deployed, with its fee split and default graduation venue. Unlike arcnow_list_tokens this is a real enumeration held in contract storage, so it is complete — there is no scan window and nothing is missed.
Use it to answer 'what can I launch under' or 'who else builds on this'. Launching does not require your own platform; arcnow.io's is the default and is one entry here among the others, not a privileged one.
Inputs: limit, offset.
arcnow_list_tokensRecent token launchesARead-onlyIdempotent
Recent arcnow.io launches, newest first, read from the launchpad's Launched log.
There is no index and no backend behind this: it walks the chain backwards from the tip in bounded chunks, so it sees a WINDOW of recent history and the result says exactly which blocks it covered. If it stopped on its budget before finding what you asked for, that is reported and is not the same as 'there are no more' — do not tell a user a token does not exist on the strength of this tool.
Filter by creator to find what one address launched. Set includeState to false when you only need the addresses; each token's curve state is an extra round trip.
Inputs: limit, creator, includeState.
arcnow_networkNetwork and server modeARead-onlyIdempotent
Which chain this server is pointed at, which arcnow.io contracts are deployed there, which graduation venues exist, whether a Uniswap v4 router is configured for trading graduated tokens, and — the part that decides what else you can do — whether this server is READ-ONLY or has writes enabled.
Call this first in any session that might trade. It tells you the spend ceilings the operator set — one per quote token, and a quote with none is refused — the address that would sign, and whether the write tools exist at all. It lists the network's quote tokens: a token is priced for life in native USDC (the gas currency, 18 decimals) or an ERC-20 such as EURC (6 decimals), and every amount is in that quote. The 6-decimal USDC ERC-20 predeploy is a separate view of native USDC that pays for nothing. Takes no arguments and touches no chain state; arcnow_quote_tokens asks the registry which quotes a launch accepts.
Inputs: no named parameters.
arcnow_platformInspect a platform's fees and defaultsARead-onlyIdempotent
One platform's configuration: who administers it, who receives its cut, how the 1% trade fee is divided FOUR ways — creator, referrer, the platform and the protocol; there is no developer share — which migrator it launches tokens into by default, and the curve template it stamps onto every token it launches.
With no address, reports arcnow.io's own platform — the default a launch uses.
The single easiest thing to misread here is what a share means. Every share is basis points OF THE FEE, never of the trade. A creator share of 3000 bps is 30% of the fee and 0.30% of the trade. This tool prints both, every time. The platform's own share is never configured: it is the residual, whatever is left after the protocol, creator and referrer shares — arcnow.io's own is creator 3000 / referrer 1000 / platform 3500 / protocol 2500.
Inputs: address.
arcnow_quote_buyQuote a buyARead-onlyIdempotent
What a given amount of the token's quote would buy right now, wherever the token trades: tokens out, every fee and who receives it — on a curve the flat 1% split four ways between creator, platform, referrer and protocol — the average price the order would fill at, and the minimum-out floor at several slippage tolerances.
Costs nothing and signs nothing. Use it before every buy, and use it INSTEAD of a spot price whenever someone asks what an amount would get them — an order moves the price across its own size, so the spot price is only ever its first infinitesimal slice.
ON A BONDING CURVE: if the buy would fill the curve, this says so, reports the refund, and explains the gas-limit trap that decides whether the token's market is created in that same transaction or never. Read that part before quoting a graduating buy to anyone.
IN A UNISWAP V4 POOL (the token graduated and migrated): the quote says it is a pool quote, priced by simulating the real swap through arcnow.io's router. It shows the two charges apart — arcnow.io's fee hook's 0.80% and the pool's own 0.20% LP fee, 1.00% in all, both read off the pool — the average fill price against the pool's spot price, and the price impact. referrer does not exist on a pool swap and is refused.
A token that graduated but never migrated trades nowhere; this says so and names arcnow_migrate. A quote is a snapshot of one block. Anyone else's trade changes it.
THE AMOUNT IS IN THE TOKEN'S QUOTE: native USDC, or the ERC-20 (such as EURC) it was launched in — arcnow_token names it. Every figure in the answer is labelled with that quote's symbol. An ERC-20 quote is pulled with an exact approval, which the answer says.
Inputs: address (required), quoteIn (required), referrer.
arcnow_quote_launchQuote a launchARead-onlyIdempotent
What launching a token would cost, before anything is spent: the launch fee the quote registry sets for the quote (zero on arcnow.io's networks — launching is free — but read live, never assumed), the initial buy, the 1% trade fee the initial buy itself pays, the tokens the creator would receive, and — given a creator address — the exact addresses the token and its curve would land at.
Costs nothing and signs nothing. Always call this before arcnow_launch and show the user the total, because a launch is irreversible: the name, symbol, supply, curve shape and graduation venue are fixed at that transaction and can never be changed afterwards, by anyone, including whoever launched it.
THE QUOTE. A token is priced for life in the quote it launches in: quote names it by symbol or address — native USDC by default, or an ERC-20 such as EURC that the quote registry accepts (arcnow_quote_tokens). The initial buy — and any launch fee — is in that quote, and so is every trade in the token afterwards. Native USDC is paid as msg.value; an ERC-20 is pulled by the launchpad after an exact approval.
The total is EXACTLY what a launch requires, not a minimum — for native USDC the launchpad reverts on an overpayment as readily as an underpayment, because it has no refund path.
Inputs: name (required), symbol (required), initialBuy (required), metadataUri (required), +4 more.
arcnow_quote_sellQuote a sellARead-onlyIdempotent
What a given quantity of tokens would fetch right now, wherever the token trades: gross proceeds, every fee and who receives it — on a curve the flat 1% split four ways between creator, platform, referrer and protocol — net proceeds in the token's quote (native USDC or an ERC-20 such as EURC), and the minimum-out floor at several tolerances.
Costs nothing and signs nothing.
ON A BONDING CURVE: selling needs NO approval, ever. The curve pulls the tokens through a privileged path that reads no allowance at all, so a holder who has approved nobody can always sell. If you find yourself suggesting an approve step before a curve sell, you are fixing the wrong problem.
IN A UNISWAP V4 POOL (the token graduated and migrated) it is the other way round, and worth telling a user before they sell: the router pulls the tokens with transferFrom, so a pool sell needs an ERC-20 APPROVAL to the router first — a separate transaction. This quote says it is a pool quote, shows arcnow.io's fee hook's 0.80% and the pool's own 0.20% LP fee apart (1.00% in all, read off the pool), the average fill against the pool's spot price, the price impact, and how much holder has approved the router for already. A pool sell is priced as a real holder, so holder must actually hold the tokens; on a writing server it defaults to the signing address. referrer is refused on a pool.
A token that graduated but never migrated trades nowhere; this says so and names arcnow_migrate.
Inputs: address (required), tokensIn (required), holder, referrer.
arcnow_quote_tokensQuote tokens a launch may useARead-onlyIdempotent
The quote tokens a token can be launched in — what its bonding curve, and later its pool, is priced in for life: native USDC (the gas currency, 18 decimals, paid as msg.value) and the ERC-20s arcnow.io's quote registry allowlists, such as EURC (6 decimals, pulled with an exact ERC-20 approval). For each: symbol, name, decimals, address, whether it is native, its launch fee in its own units (zero on arcnow.io's networks — launching is free — but read from the registry, never assumed), whether the registry accepts it for new launches now, and this server's spend cap for it.
SPEND CAPS ARE PER QUOTE, AND FAIL CLOSED. The operator caps native USDC with ARCNOW_MCP_MAX_SPEND_USDC (default 100) and every other quote with ARCNOW_MCP_MAX_SPEND_, in that quote's own units (ARCNOW_MCP_MAX_SPEND_EURC=50). A quote with no cap is REFUSED for every launch and buy, and a quote this network does not list can have no cap at all. Tell the user which quotes they can actually spend here before offering a launch or a buy in one.
Reads the registry in at most three eth_calls. If the chain has no quote registry to ask — a deployment older than quote registries has none — this says so, shows the error, and lists this network's own quote-token metadata instead, with NOTHING known to be accepted. Takes no arguments and spends nothing.
Inputs: no named parameters.
arcnow_tokenInspect a token and where it tradesARead-onlyIdempotent
Everything about one arcnow.io token: its metadata, its bonding curve's live state, the price, how far it is from graduation, whether it has graduated — and WHERE IT TRADES NOW: its bonding curve, its Uniswap v4 pool, or nowhere.
For a token in its pool this reports the router this server would trade through, whether that router can actually reach the pool, the PoolManager the liquidity is in (a v4 pool has no address of its own), and what a trade there costs — arcnow.io's fee hook's 0.80% plus the pool's own 0.20% LP fee, 1.00% in all, both read off the pool.
It names the token's QUOTE TOKEN — native USDC or an ERC-20 such as EURC, fixed at launch — with its address and decimals: every amount here, and every amount the trade tools take for this token, is in that quote.
Pass either the token address or its curve address; this works out which it got. Pass holder to include that address's balance and any refund the curve is holding for it.
Two things this tool reports that are easy to misread. The spot price is the marginal price of the next infinitesimal token, NOT the price a trade of any size fills at — use arcnow_quote_buy for that. And 'graduated' and 'migrated' are different states: a curve can have graduated (trading on it is over, permanently) while its pool was never created, which leaves the token tradeable nowhere until somebody runs migrate().
Inputs: address (required), holder.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool targets a distinct concern: quote token registry, launch quoting, token state, buy/sell quoting, platform config, platform/token listings, and network info. Even where topics touch (quote_tokens vs network both mention quote tokens), their roles are clearly separated by description.
All tools share the arcnow_ prefix, but the pattern after it is mixed: some are noun-only (token, platform, network) while others are verb_noun (list_platforms, list_tokens, quote_buy, quote_sell). The prefix provides strong coherence, though a uniform verb_noun style would be more predictable.
Nine tools cover the read/quote side of a token launch and trading platform without redundancy. The count feels well-scoped for the apparent domain.
The set is severely incomplete for a launch/trading server: arcnow_quote_launch explicitly references arcnow_launch, and arcnow_token references arcnow_migrate, but no actual execution tools (launch, buy, sell, migrate) are present. Agents can quote but never act, leaving core lifecycle operations missing.
Maintenance
Related MCP Connectors
Find and buy paid APIs for AI agents on Arc. Pay per call in USDC over x402.
Human-governed Arc agent services, live demand signals, quotes, feedback, and USDC commerce.
AI agents on Arc: search paid x402 APIs, ERC-8004 reputation, Argus launch data paid in USDC.
An AI treasury agent paying in USDC on Arc: read its decisions, ledger and books; add invoices.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI tools to access Arc Testnet blockchain data, including USDC balances, transactions, blocks, and network info.7MIT
- AlicenseAqualityDmaintenanceLets MCP-capable AI agents interact with the Arcade DEX and launchpad on Circle's Arc L1 to discover markets, get quotes, and execute trades via contract-call descriptors.87 npmMIT

BullCheese MCPofficial
AlicenseNot gradedqualityCmaintenanceEnables AI agents to launch and trade tokens on the ARC blockchain by providing a wallet, supporting token creation and swaps through Team Finance's MintPlus.MIT- AlicenseAqualityBmaintenanceEnables reading live market state on Arc (chainId 5042) including launchpads, LP APRs, RPC consensus, token screens, honeypot simulations, and an agent directory.1219 npmMIT