OneSource MCP is a unified MCP server for live blockchain RPC queries, OneSource API data, Deepstate market data, The Standard Reserve analytics, and REST API docs; the README advertises 99 tools, but the supplied schema exposes 27 RPC/setup tools.
Query live ERC20/ERC721/ERC1155 balances, allowances, owners, metadata, total supply, and multi-token balances.
Query chain/network state and transactions: blocks, chain ID, gas price/estimate, nonce, pending block, tx details/receipts, event logs, and ERC20 transfers.
Inspect contracts: bytecode, ERC165 type detection, proxy/implementation detection, storage reads, eth_call simulation, and ENS resolution.
Use README-advertised paid data tools for Deepstate markets (order books, trades, candles, stats, makers, depth) and The Standard Reserve (auctions, charters, branches, backing, supply, policy, vaults, S-Bills, decision tools).
Manage payments/auth via API key, x402 on Base, or MPP on Tempo; switch payment modes, open channels, and refund unused deposits.
Search OneSource REST API documentation, list endpoints/networks, get endpoint references, and authentication/payment guidance.
Run setup/health checks and report bugs; documentation and setup/ops tools are free. Schema networks: ethereum, sepolia, avax; README also lists robinhood.
Integrates with the Coinbase-developed x402 protocol to handle USDC payments on the Base network for blockchain API access.
Provides comprehensive access to Ethereum blockchain data, including tools for querying live and indexed transaction history, token balances (ERC20, ERC721, ERC1155), smart contract metadata, and ENS resolution.
Offers specialized tools for exploring and searching GraphQL API documentation, including schema definitions, type definitions, and query patterns for building specific blockchain data requests.
Unified MCP server for OneSource — 91 tools for blockchain data, live chain queries, Deepstate market data, The Standard Reserve, and REST API documentation in a single server.
What is MCP? The Model Context Protocol lets AI assistants call tools and access data sources. This server exposes both the OneSource blockchain API and its documentation as tools.
claude mcp add onesource -- npx -y @one-source/mcp@latestAdd to your MCP config:
{
"mcpServers": {
"onesource": {
"command": "npx",
"args": ["-y", "@one-source/mcp@latest"]
}
}
}npx -y @one-source/mcp@latestnpx -y @one-source/mcp@latest --http
npx -y @one-source/mcp@latest --http --port=8080Then connect your MCP client to http://localhost:3000/ (or your --port value, e.g. 8080 in the second example above).
Health check: GET http://localhost:3000/health (substitute your port).
Related MCP server: sui-analytics-mcp
Tool | Description |
| ERC20 allowance check |
| Contract type detection via ERC165 |
| ERC1155 balance via RPC |
| ERC20 balance via balanceOf |
| ERC20 Transfer logs via eth_getLogs |
| ERC721 token enumeration |
| Event logs via eth_getLogs |
| ETH + multiple ERC20 balances |
| NFT metadata via tokenURI |
| NFT owner via ownerOf |
| Token total supply |
| Transaction + receipt via RPC |
RPC only.
Tool | Description |
| Block details by number via RPC |
| Latest block number |
| EIP-155 chain ID |
| Contract bytecode |
| ENS name/address resolution |
| Gas estimation |
| Chain ID, block number, gas price |
| Transaction count |
| Pending block from mempool |
| Proxy contract detection |
| Simulate eth_call |
| Read storage slot |
| Transaction receipt |
Tool | Description |
| View or switch the payment rail + scheme across all four modes: |
| Reclaim an open payment channel's unspent deposit on demand — works for both an x402 |
Deepstate is an on-chain order-book protocol on Robinhood Chain (chain 4663). These tools read market data — order books, trades, candles, stats, maker analytics, and gas/depth analytics. They're ordinary tools on the same API and take no network parameter — always Robinhood Chain — and are paid like every other tool: API key, x402, or MPP. Since the DGP-3 migration (2026-09-22), maker rewards are per-market rather than a single fixed token — always check a market's reward_token on 1s_ds_markets rather than assuming DEEP.
Tool | Description |
| List the Deepstate markets (order books) this API serves, with each market's slug, token layout, pool/router addresses, |
| Order-book snapshot for a market — bids descending, asks ascending, with each price level's resting size |
| Trade tape for a market, newest first — each fill's price, size, side, and block |
| OHLCV candles for a market at a given timeframe |
| Rolling 24h / 7d / 30d volume and price change for a market, plus the latest traded price |
| Per-maker analytics for a market — time at top of book, resting notional, fill count/rate, and maker rewards earned (reward token is per-market — see |
| Gas spent resting and cancelling orders on a market, bucketed over time |
| Depth heatmap for a market — resting order size by price level over time |
| 2DEEP supply, cap, float, reward pool and endowment balances, migration liabilities, and pool price — live from chain |
| DEEP/STATE-to-2DEEP redemption progress since DGP-3 (2026-09-22): totals, counts, remaining, and a daily series |
Every Deepstate tool except 1s_ds_markets takes a book parameter: the market's canonical uppercase slug (e.g. NVDA-USDG) or its 32-byte book_id. Call 1s_ds_markets first for the full list.
The Standard Reserve is an on-chain central-bank protocol on Robinhood Chain (chain id 4663). These tools read the deployed contracts' state as indexed and served by OneSource, with basis, as_of_block, and serving_state on every response. 1s_std_addresses and 1s_std_genesis_live are free; every other tool here is paid the same way as the rest of this API: API key, x402, or MPP. Several tools (1s_std_supply, _vaults, _pool, _exit_pressure, _backing, _policy_current) also take an atBlock param to read that state as of a past block instead of the latest one.
Tool | Description |
| Verified registry of TSR contracts and pool, with a verification status per entry. Free, no payment required. |
| Per-day auction history for the license or charter auction: open/floor/close price, sold vs. offered, time to sell out; license days add purchase counts, distinct charters, average and total paid, and a purchases-per-transaction breakdown |
| Recent sales for the license or charter auction, newest first: buyer, unit price, count, and block. Filter by kind, page with before/limit |
| Current state of the daily license auction and charter auction: price, floor, sold/remaining today, phase, and last sale |
| Reserve backing: vault ETH balances, reserve-asset holdings, the vault's Uniswap v4 positions, and ETH backing per STANDARD in three variants: vault ETH only, with protocol-owned liquidity added, and with all reserve assets added at the Reserve's own pool prices (USDG at $1). Current, history, or as of a past block |
| Raw head-fresh state of the Branch license auction: phase, price, today's sold/remaining counts, and recent sale velocity |
| Days of Issuance for the Branch license auction, plus a buy-now-vs-wait table |
| Summary across TSR's active Branches: count, issuance per Branch per day, and license price in days of issuance |
| Contraction-vault buyback-tick readiness: this tick's ETH capacity, binding constraint, cooldown, TWAP deviation, and recent executed ticks |
| OHLC price candles for the ETH/STANDARD pool in ETH per STANDARD, with swap counts and volume. Set tf for candle width (1m to 1d) and from/to for the window |
| One charter by id, or charters filtered by owner: holder, branch count, mint kind, owed production, branch history, its share of the one-time charter stimulus (claimable by the charter's owner until a deadline returned in the response), and its share of each launchpad charter drop |
| Composite: should I buy a Branch/license right now. Bundles Days of Issuance, license cost vs. the charter auction, recent auction history, policy outlook, pending governance changes, and what a branch earned in past launchpad charter drops (history, not a forecast) |
| Composite: when would a standing license-auction bid at this max price be reached, how many bids and licenses are ahead of it, and (with |
| Composite: should I buy into a new charter right now. Bundles charter-auction state, license-cost cheapest path, Days of Issuance, backing ratio, holder concentration, and what a branch earned in past launchpad charter drops (history, not a forecast) |
| Composite: should I exit a charter's branches right now. Bundles the exit quote, fee curve, fee forecast, tax schedule, pool state, policy outlook, pending governance changes, the unclaimed stimulus a full exit forfeits, and the charter drops closing would release, with a noteOwner warning |
| Composite: should I keep holding STANDARD. Bundles the policy outlook, issuance runway, pending governance changes, tax schedule, buyback readiness, and dormancy state; takes no arguments |
| Simulate three Branch-buying strategies (keep, selective, aggressive) over a horizon, seeded from live prices, issuance, and license cost unless overridden. With a charter id, launchpad drop shares appear beside the strategies and outside every ETH result. A planning tool, not a forecast: it never names a winning strategy |
| Composite: what should I do with this S-Bill. Before maturity: the exit payout now, the premium given up, and the exit fee on each coming day if nobody else exits (derived). After maturity: the redeem payout and what a roll would lock (derived), and the note that there is no auto-roll. Takes |
| Composite: should I stake this STANDARD in an S-Bill now, or wait. Bundles the S-Bills quote, caps checked against the wallet, the exit fee right after depositing, and the rate over 1h/6h/24h if nobody else deposits (derived). Takes |
| Wallets past their reportable dormancy window, or the full tracked wallet list |
| Dormancy bounty board: wallets already past their reportable window, ranked by estimated bounty |
| TSR epoch history: net flow, signal, regime, multiplier, and issuance per epoch. Page with before/limit |
| Raw decoded protocol events, optionally filtered by contract_label, event_name, addresses, token_id, epoch, or block/log cursor, and paginated with before/limit |
| How the exit fee changes with withdrawal size: current fee rate plus a ladder at 1/5/10/25/50/100% of a gross withdrawal |
| Current-pace projection of the exit fee if no more withdrawals happen, day by day, plus days until the fee reaches its floor and the exact instant each recorded withdrawal day leaves the fee window |
| Exit-pressure reading and the resulting resolution fee rate. Current, history, or as of a past block |
| Pro-rata exit quote for retiring a charter's open Branches, plus a realizable-ETH estimate as of a given block |
| ETH/STANDARD pool buys and sells grouped by wallets that held a Charter when each swap happened. Set hours and limit for the result window |
| Hourly ETH flow into and out of the ETH/STANDARD pool, with swap counts. Set hours for how far back to look |
| Head-fresh stats for the genesis Dutch mint: phase, minted, remaining, price, and sale velocity. Free. |
| Governance/param-change history across TSR's 15 tracked contracts, what's currently queued, switch states, and guardian pause state |
| Charter/Branch ownership concentration: distribution across Charters, top owners, an HHI (Herfindahl-Hirschman Index) score, and the genesis-vs-auction cohort split |
| Cumulative STANDARD issued against the Central Bank's issuance budget, current stream rate, and a same-state projection of when the budget runs out |
| Every standing bid on the license auction, read at one block: bidder, count, max unit price, whether the contract can fill it, what blocks each bid, stale or prunable flags, and a derived effective crossing price. Filter by charter, bidder or fillable, and sort |
| What a Branch license costs in ETH right now, and whether the charter auction is a cheaper path to the same outcome |
| How many more Branch licenses a charter can still buy today, with a live per-unit quote ladder |
| Current epoch's monetary policy: regime, multiplier, net flow, and the two-epoch signal. Current or as of a past block |
| Same-state projection of the policy multiplier and issuance rate if the current epoch's net-flow sign holds to close |
| Latest ETH/STANDARD Uniswap v4 pool state: price, tick, liquidity, reserves, and remaining launch tax. Current or as of a past block |
| Money movements by the protocol, newest first: holdings migrated, taxes forwarded, fees recycled, team claims, POL buybacks, fees and pairings, incentive sends, and outflows from the multisig-held reserve vault with the method that moved them and a |
| One S-Bill by id, or S-Bills filtered by owner or status: principal, premium, locked rate, maturity, and how each closed. The single-bill form also returns a live exit and redeem quote |
| S-Bills staking terms right now: the per-term rate and its simple APR, drift state, locked principal, premium budget, caps, and the early-exit fee window. Rates are per term, not annual |
| Decoded S-Bills contract events, newest first: deposits, early exits, redemptions, rolls, settlements, bonus distributions, rate changes, and admin changes |
| Live quote for staking STANDARD into an S-Bill: the rate you'd lock, the premium escrowed, the rate after your deposit, and whether caps or a pause would block it. Read straight from the contract |
| How the S-Bill rate has moved: every on-chain rate change plus periodic drift samples, each tagged with the term length in force at the time |
| STANDARD supply ledger: circulating, cumulative minted, cumulative burned by path, max supply, and the unclaimed charter stimulus (null for past blocks). Current, history, or as of a past block |
| Launch tax-hook schedule: current buy/sell tax, decay configuration, and a labeled projection while the launch schedule is active |
| Expansion and Contraction vault balances: WETH and STANDARD held, protocol-owned liquidity, and buyback capacity. Current, history, or as of a past block |
| One wallet's full TSR position across every Charter it holds: pending owed, a summary exit quote, dormancy status, license headroom, claimable charter stimulus, and claimable and locked charter drops |
No authentication required. These answer from a documentation corpus bundled with the server, so they cost nothing and work even before a payment method is configured. They share their names with the standalone @one-source/docs-mcp server, which serves the same corpus.
Tool | Description |
| Keyword search across the OneSource developer documentation |
| What the REST API covers — operation count, tags, networks, payment protocols |
| Every REST endpoint with method, path, price, and summary; filter by tag |
| One endpoint in full — parameters, request body, example response, price, curl |
| Find the right endpoint from a plain-language description of the task |
| Networks the REST API routes, as declared by its published spec |
| Price range, payment rails, and pay-to address; per-endpoint when given one |
| How to authenticate to the REST API and which method to choose |
No authentication required.
Tool | Purpose | When to use |
| Interactive setup & health check. Walks the user through every configuration choice for both rails (auth method, x402, MPP, payment modes, channel prefs) one decision at a time — every run, even when already configured — plus version, auth status, channel status, and connectivity | First thing to call — to set up, change configuration, or troubleshoot |
| View or change payment-channel preferences (autonomy, threshold, x402 deposit multiplier, MPP session deposit cap, default mode) and persist them across restarts — no config editing required | Configure channel behaviour from the session |
| Report bugs to Slack (or GitHub Issues fallback) | When a tool errors or user wants to report an issue |
All blockchain API tools accept an optional network parameter:
Network | Description |
| Ethereum mainnet (default) |
| Ethereum Sepolia testnet |
| Robinhood Chain, chain 4663 (Arbitrum Orbit L2) — live-RPC only |
Blockchain API tools require authentication. Three options are available — if an API key is set alongside a wallet key, the API key takes priority and the wallet is ignored.
Tip: the fastest way to configure any of these is the
1s_setup_checktool — it walks you through every option interactively and hands you a ready-to-run command, so you never have to hand-edit env vars or config files. The manual instructions below are the reference.
Method | Variable | Description |
API key |
| Unlimited calls, no per-call cost |
x402 micropayments |
| Pay-per-call via USDC on Base, no account required |
MPP micropayments |
| Pay-per-call via USDC.e / pathUSD on Tempo, no account required |
Go to app.onesource.io and create an account.
Complete the API key subscription through Stripe checkout.
Navigate to API Keys and generate a key.
Copy the key — it starts with sk_.
claude mcp add onesource -e ONESOURCE_API_KEY=<key> -- npx -y @one-source/mcp@latestAdd the env block to your MCP config:
{
"mcpServers": {
"onesource": {
"command": "npx",
"args": ["-y", "@one-source/mcp@latest"],
"env": {
"ONESOURCE_API_KEY": "<key>"
}
}
}
}ONESOURCE_API_KEY=<key> npx -y @one-source/mcp@latestAfter adding, reload the MCP server and call 1s_setup_check — under Current configuration it should report Active auth method: API key (with the first 6 characters of your key).
Blockchain API endpoints are priced in USDC on Base via x402. When you set X402_PRIVATE_KEY, the server automatically handles payments — tool calls are paid and retried transparently without any extra work from the agent.
Get an EVM private key — export one from MetaMask, Coinbase Wallet, or any EVM wallet, or generate a fresh one. The key is a 64-character hex string. The 0x prefix is optional — both formats are accepted.
Pass the key to the server using one of the methods below.
Reload and find your wallet address — reload the MCP server, then call 1s_setup_check. Under Current configuration it lists your x402 (Base) wallet — the address derived from your key.
Fund that address with USDC on Base — send USDC to the address shown in 1s_setup_check, on the Base network. A few dollars ($1–5 USDC) is enough for hundreds of calls. If your USDC is on Ethereum mainnet, bridge it using the Base Bridge.
Verify — call 1s_network_info for ethereum. If it returns chain data (block number, gas price), x402 payments are working end-to-end.
claude mcp add onesource -e X402_PRIVATE_KEY=<key> -- npx -y @one-source/mcp@latestAdd the env block to your MCP config:
{
"mcpServers": {
"onesource": {
"command": "npx",
"args": ["-y", "@one-source/mcp@latest"],
"env": {
"X402_PRIVATE_KEY": "<key>"
}
}
}
}X402_PRIVATE_KEY=<key> npx -y @one-source/mcp@latestBlockchain API endpoints can also be paid on the Tempo network via MPP — an alternative to x402 on Base. When you set MPP_PRIVATE_KEY, the server handles payments automatically; tool calls are paid and retried transparently.
Get an EVM private key — same format as x402 (64-char hex, 0x optional). Export one or generate a fresh key.
Pass the key to the server using one of the methods below.
Reload and find your wallet address — reload the MCP server, then call 1s_setup_check. Under Current configuration it lists your MPP (Tempo) wallet — the address derived from your key.
Fund that address with USDC.e or pathUSD on Tempo — a few dollars covers hundreds of calls.
Verify — call 1s_network_info. If it returns chain data, MPP payments are working end-to-end.
claude mcp add onesource -e MPP_PRIVATE_KEY=<key> -- npx -y @one-source/mcp@latest{
"mcpServers": {
"onesource": {
"command": "npx",
"args": ["-y", "@one-source/mcp@latest"],
"env": {
"MPP_PRIVATE_KEY": "<key>"
}
}
}
}MPP_PRIVATE_KEY=<key> npx -y @one-source/mcp@latestBy default MPP pays per call (mpp-charge). For a burst of calls, switch to a Tempo voucher channel with 1s_payment_mode { "mode": "mpp-session" } (or set MPP_PAYMENT_MODE=session) — one deposit funds many off-chain calls; reclaim the unspent balance any time with 1s_refund, or it settles automatically on clean shutdown.
If you prefer editing the config file directly instead of using CLI commands:
Client | Config file path |
Claude Code | Run |
Claude Desktop (macOS) |
|
Claude Desktop (Windows) |
|
Cursor (macOS) |
|
Cursor (Windows) |
|
Add the onesource entry inside "mcpServers" using the JSON block shown above.
Instead of the env config block, you can set any of these variables as a shell or system environment variable: export ONESOURCE_API_KEY=<key> (bash/zsh) or $env:ONESOURCE_API_KEY = "<key>" (PowerShell). Set it at the OS level for persistence across sessions.
By default each paid call signs one payment per call (x402-exact on Base, mpp-charge on Tempo). For a burst of calls, open a payment channel — one on-chain deposit funds many off-chain calls, settled together — which is cheaper than paying per call:
x402 (Base): switch to x402-batch with 1s_payment_mode { "mode": "x402-batch" } (or X402_PAYMENT_MODE=batch). The first call deposits price × X402_DEPOSIT_MULTIPLIER (default 10).
MPP (Tempo): switch to mpp-session with 1s_payment_mode { "mode": "mpp-session" } (or MPP_PAYMENT_MODE=session). The first call deposits up to MPP_MAX_DEPOSIT (default 1).
Reclaim the unused balance any time with the 1s_refund tool (works for both rails); the residual is always recoverable on-chain. An idle x402 channel also auto-refunds after a few hours, and an MPP session settles automatically on clean shutdown.
When paying via a wallet, the agent receives channel guidance in its system prompt at startup, so it can manage this for you rather than leaving it as a manual step: when it anticipates a burst of calls it offers to switch to the channel mode for the active rail and reminds you to 1s_refund when finished. Control how proactive it is with X402_BATCH_PROMPT (ask / auto / off) and X402_BATCH_THRESHOLD (how many anticipated calls count as a burst — shared across both rails) — see Environment Variables. 1s_setup_check reports your current mode, whether the channel is available, and all settings.
Never commit keys to source control. Use environment variables, a .env file (excluded from git), or a secrets manager.
After any config change: Run
/reload-pluginsin Claude Code, or restart Claude Desktop / Cursor. The MCP server must be reloaded to pick up new environment variables.
Set one to access the blockchain API tools. Without any, only the no-auth Setup & Ops tools work. The API key takes priority when set alongside a wallet key.
Variable | Default | Description |
| — | OneSource API key for Bearer token auth. Takes priority over the wallet rails. |
| — | EVM private key (64-char hex, |
| — | EVM private key for automatic MPP payments (USDC.e / pathUSD) on Tempo. |
All have sensible defaults — channel modes run out of the box. Set these only to override an endpoint, tune how channel modes behave, or adjust analytics. Payment modes can also be switched at runtime with the 1s_payment_mode tool. The channel knobs below (X402_PAYMENT_MODE, X402_DEPOSIT_MULTIPLIER, MPP_PAYMENT_MODE, MPP_MAX_DEPOSIT, X402_BATCH_PROMPT, X402_BATCH_THRESHOLD) can be set and persisted from a session with the 1s_batch_config tool — no config editing or restart required; a saved config takes priority over these env vars.
Variable | Default | Description |
|
| API base URL. |
|
| Initial x402 scheme: |
| Base default | Base RPC endpoint used to submit channel deposits in batch mode. |
|
| Batch mode: deposit = price × this multiplier, funding that many calls per channel. Unused balance is reclaimable via |
| — | Directory to persist batch channel state across restarts. Unset = in-memory (channel lost on restart). |
| zero | Batch mode: 32-byte hex salt to derive the starting channel id. The client auto-rotates to the next salt when a channel is exhausted or refunded. |
|
| Initial MPP scheme: |
|
| Session mode: max USDC.e / pathUSD locked per Tempo voucher channel. Unused balance is reclaimable via |
| Tempo default | Tempo RPC endpoint used to submit channel deposits in session mode. |
|
| How the agent handles switching to a channel mode (both rails): |
|
| Number of anticipated calls in a session at/above which the agent considers a channel mode (both rails). Advisory — the agent estimates the call count; it is not a hard runtime counter. |
|
| Directory holding the server-managed channel config ( |
|
| Set to |
|
| Dashboard endpoint for analytics. |
|
| API key for dashboard analytics. Legacy alias |
1s_setup_check shows "Active auth method: none" (blockchain tools locked)
Under Current configuration, "Active auth method: none" means no authentication is set. Set one of ONESOURCE_API_KEY (API key), X402_PRIVATE_KEY (x402 on Base), or MPP_PRIVATE_KEY (MPP on Tempo) — or just run 1s_setup_check and let it walk you through it. Reload the MCP server after setting any variable (see note above). If the key still isn't reaching the server, set it as a shell environment variable directly.
Getting 403 / wrong key active despite correct setup
A key set in your shell profile (e.g. ~/.zshrc, ~/.bash_profile) is picked up by the MCP server process even if it isn't in your Claude MCP config. Run echo $ONESOURCE_API_KEY in your terminal to check. If it prints a value you didn't intend, unset it (unset ONESOURCE_API_KEY) or explicitly clear it when adding the server: claude mcp add onesource -e ONESOURCE_API_KEY= -e X402_PRIVATE_KEY=<key> -- npx -y @one-source/mcp@latest. 1s_setup_check shows the first 6 characters of whichever key is active so you can confirm which one the server is using.
Instructions show wrong auth method after reinstall
/reload-plugins in Claude Code reconnects tools but may not refresh the system prompt the LLM sees. If you switch auth method (e.g. API key → x402), do a full Claude Code restart to ensure the instructions reflect the new auth.
"MCP server onesource already exists" error
Run claude mcp remove onesource first, then re-add with your updated config.
Windows: npx requires cmd /c wrapper
Claude Code's /doctor command may warn about this. Update your MCP config to use "command": "cmd" with "args": ["/c", "npx", "-y", "@one-source/mcp@latest"].
**npx hangs with no output**
That's normal — stdio mode waits for JSON-RPC input on stdin. Use --http if you want an HTTP server you can curl.
Port already in use
Specify a different port: npx -y @one-source/mcp@latest --http --port=8080
This package is listed on the official MCP Registry under the verified namespace io.onesource/mcp and on Glama. When releasing a new version, update both registries.
Download the installer for your platform from go.dev/dl and run it. Verify:
go versiongo install github.com/modelcontextprotocol/registry/cmd/mcp-publisher@latestIf the Go module path has changed and the command fails, download the binary directly from the mcp-publisher GitHub releases page instead.
On Windows, add Go's bin directory to your PATH if the command isn't recognized:
$env:PATH += ";$env:USERPROFILE\go\bin"Verify:
mcp-publisher --helpThe onesource.io domain has a DNS TXT record that proves ownership of the io.onesource namespace. This is already configured — you don't need to redo it.
The record is on the root domain (onesource.io, not _mcp-registry.onesource.io):
v=MCPv1; k=ed25519; p=7D3U5rufgNXb/lH2MthTRZdDzEGeE7/Jvg8YkiArQc8=You can verify it resolves:
nslookup -type=TXT onesource.io 8.8.8.8Authentication requires the ed25519 private key in hex format that corresponds to the public key in the DNS record. Ask the team lead for this key — it's stored in the team's password manager / vault.
If you need to regenerate the keypair (this invalidates the current DNS record and requires updating it):
Generate a new ed25519 keypair (e.g., openssl genpkey -algorithm Ed25519 -out key.pem)
Extract the raw 32-byte private key seed and convert to hex:
openssl pkey -in key.pem -outform DER | tail -c 32 | xxd -p -c 32Extract the public key in base64 for the DNS TXT record:
openssl pkey -in key.pem -pubout -outform DER | tail -c 32 | base64Update the DNS TXT record on onesource.io with the new public key:
v=MCPv1; k=ed25519; p=<base64-public-key>Wait for DNS propagation before attempting to log in.
Use the release script. Releases are normally run via the coordinated release script in the sre-services repo (
scripts/release-mcp.mjs— seesre-services/RELEASING.md), which performs all of the steps below across both@one-source/api-mcpand@one-source/mcpin the correct order, including theserver.jsonbump andmcp-publisher publish. The First-Time Setup above is still the prerequisite for the registry step. The manual steps below are the fallback for registry-only fixes or when the script can't run.
Every time you release a new npm version, update the MCP Registry:
Publish to npm (the registry validates the package exists, so this must happen first):
npm run build
npm publish --access publicUpdate server.json — set both version fields to match the new npm version:
{
"version": "x.y.z",
...
"packages": [{ "version": "x.y.z", ... }]
} The mcpName field in package.json must be "io.onesource/mcp" and must match the name field in server.json. This is already set — don't remove it.
3. Authenticate (tokens expire, so do this each time):
mcp-publisher login dns --domain onesource.io --private-key <ed25519-hex-private-key>Publish to the registry:
mcp-publisher publishVerify:
curl "https://registry.modelcontextprotocol.io/v0.1/servers?search=onesource"Glama auto-syncs from the GitHub repo daily. No manual steps needed after a release — just make sure changes are pushed to develop (the default branch). The glama.json file in the repo root controls ownership. Manual re-sync is available from the Glama admin panel after claiming the server.
Use of this extension connects to the OneSource API. See the OneSource Privacy Policy for details on how data is handled.
Apache 2.0 — see LICENSE for details.
Check ERC20 token allowance (approved spending amount) via the allowance(owner,spender) RPC call. Use this before executing transferFrom or to verify approvals. Returns the allowance amount in raw token units.
Inputs: owner (required), spender (required), token (required), network.
Get full block details by block number via RPC. Returns transactions, gas used, miner, timestamp, and other header fields. Accepts decimal (e.g. "21000000") or hex (e.g. "0x1406F40") block numbers.
Inputs: number (required), network.
Get the latest block number for a network. Returns the current chain head as a hex-encoded value. Use 1s_network_info to also get chain ID and gas price in the same call.
Inputs: network.
Get the EIP-155 chain ID for a network as a hex-encoded value. Use this to verify the network before signing transactions. Use 1s_network_info to get chain ID, block number, and gas price together.
Inputs: network.
Get the deployed bytecode of a contract via eth_getCode. Returns '0x' for EOA (non-contract) addresses. Bytecode can be very large for complex contracts. Prefer 1s_proxy_detect or 1s_contract_info_live for type checks without fetching full bytecode.
Inputs: address (required), network.
Detect contract type and supported interfaces via eth_getCode and ERC165 supportsInterface. Returns detected standards (ERC20, ERC721, ERC1155, ERC165).
Inputs: address (required), network.
Resolve ENS names to addresses (forward) or addresses to ENS names (reverse). Accepts either a .eth name or a 0x address. Only works on networks with ENS registry deployed (mainnet, sepolia).
Inputs: input (required), network.
Get real-time ERC1155 token balance via balanceOf(address,uint256) RPC call. Returns the raw balance as a numeric string.
Inputs: account (required), contract (required), token_id (required), network.
Get real-time ERC20 token balance directly from the blockchain via balanceOf. Use this for pre-transaction checks or when zero indexing delay is needed. Returns raw token units (divide by 10^decimals); non-standard tokens may return empty name/symbol.
Inputs: account (required), token (required), network.
Query ERC20 Transfer(from, to, value) event logs via eth_getLogs directly from the node. Filter by token contract and/or wallet address. Block params are hex-encoded (e.g. 0x1234). Returns decoded transfer events with sender, recipient, and value. WARNING: Keep block ranges small (10 blocks or fewer) to avoid huge responses. Omitting from_block/to_block queries only the latest block.
Inputs: token, wallet, from_block, to_block, +1 more.
Enumerate ERC721 tokens owned by an address via ERC721Enumerable. Only works for contracts that implement the Enumerable extension. Returns token IDs owned by the address.
Inputs: owner (required), contract (required), network.
Estimate gas required for a transaction via eth_estimateGas. Use this before sending transactions to set appropriate gas limits. Returns the estimated gas as a hex value; reverts return the revert reason.
Inputs: to (required), data, from, value, +1 more.
Query raw event logs via eth_getLogs directly from the node. Filter by contract address and/or topic0 (keccak256 hash of event signature, e.g. Transfer(address,address,uint256)). Block params are hex-encoded (e.g. 0x1234). Returns raw log entries with topics, data, and block context. WARNING: Keep block ranges small (10 blocks or fewer) to avoid huge responses. Always specify a contract address when possible. Omitting from_block/to_block queries only the latest block.
Inputs: contract, topic, from_block, to_block, +1 more.
Get ETH and multiple ERC20 balances in a single batched RPC call. Use this to check a wallet's holdings across multiple tokens efficiently. Individual token errors are returned per-token without failing the entire request.
Inputs: address (required), tokens, network.
Get basic network information: chain ID, latest block number, and current gas price. Use this to verify which chain you are connected to or to check current gas conditions. Returns hex-encoded values; gas price is in wei.
Inputs: network.
Fetch NFT metadata directly from the blockchain via tokenURI/uri RPC call. Resolves all URI formats: ipfs://, ar://, data: URIs, bare CIDs, and ERC1155 {id} templates.
Inputs: contract (required), token_id (required), network.
Get the current NFT owner via ownerOf(tokenId) RPC call. Only works for ERC721 tokens.
Inputs: contract (required), token_id (required), network.
Get the transaction count (nonce) for an address via eth_getTransactionCount. Use this to set the correct nonce when constructing transactions. Returns the count as a hex value.
Inputs: address (required), network.
Get the current pending block from the mempool. Use this to see transactions waiting for inclusion. WARNING: Response can be very large (1MB+) on mainnet as it includes all pending transactions. Prefer 1s_network_info for chain status or 1s_tx_details_live for specific transactions. Not all nodes expose pending block data; results vary by RPC provider.
Inputs: network.
Detect if a contract is a proxy and read its implementation address. Checks EIP-1967 (transparent/UUPS/beacon) storage slots. Returns the proxy type, implementation address, and admin if applicable.
Inputs: address (required), network.
Report a bug or issue to the OneSource team. Use when a tool returns an unexpected error or when the user asks to report a problem. Free, no payment required.
Inputs: description (required), tool_name, error_message, severity, +2 more.
Check OneSource MCP server health — version (current vs latest), authentication status (API key or x402), API connectivity, and setup instructions if anything is missing. Free, no authentication required. Call this first when troubleshooting.
Inputs: no named parameters.
Simulate a contract call via eth_call without sending a transaction. Use this to preview call results, decode return data, or check for reverts before sending. Returns the raw hex result or revert reason.
Inputs: to (required), data (required), from, value, +2 more.
Read a raw storage slot from a contract via eth_getStorageAt. Use this for low-level state inspection (e.g. reading proxy implementation slots, packed storage). Slot must be a hex-encoded 32-byte value.
Inputs: contract (required), slot (required), network.
Get the total supply of an ERC20 or ERC721 token via totalSupply() RPC call. Use this for real-time supply data. Returns raw token units for ERC20 (divide by 10^decimals) or total count for ERC721.
Inputs: contract (required), network.
Get full transaction data and receipt directly from the RPC node. Returns both transaction fields and receipt (status, gas used, logs).
Inputs: hash (required), network.
Get a transaction receipt via RPC. Returns status (1=success, 0=revert), gas used, logs, and contract address if deployment. Use 1s_tx_details_live for both transaction data and receipt together.
Inputs: hash (required), network.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 27 tools
Most tools have distinct purposes, e.g., 1s_allowance_live vs 1s_erc20_balance_live, 1s_tx_details_live vs 1s_tx_receipt. Some overlap exists (e.g., 1s_network_info includes block number and chain ID) but descriptions guide usage clearly.
All tools share the '1s_' prefix and use snake_case. Names are descriptive, though patterns vary (e.g., verb_noun in 1s_estimate_gas, noun_adjective in 1s_allowance_live). Minor inconsistency but overall readable.
27 tools for an Ethereum RPC server is slightly above average but each covers a specific RPC endpoint or operation. The scope is broad, so the count is reasonable and not excessive.
The tool set covers nearly all important Ethereum interactions: balances, transactions, events, ENS, contract inspection, gas estimation, and more. A setup check and bug report tool add to completeness. No major gaps for the domain.
Free MCP server of security & dev API tools -- supply-chain, CVE, DNS, WHOIS, OFAC, Cosmos SDK.
Self-hosted MCP server: 26 deterministic dev, security, and EVM tools.
Crypto market intelligence, token rug-checks, and wallet verification in one MCP server.
MCP server connecting AI agents to non-custodial staking data across 130+ networks.
