Radiant MCP Server
OfficialClick 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., "@Radiant MCP Server resolve WAVE name example"
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.
Radiant MCP Server
Model Context Protocol (MCP) server for the Radiant blockchain — lets AI agents query chain state, manage Glyph tokens, resolve WAVE names, and — when given a private key — build, sign, and broadcast transactions on the Radiant network.
⚠️ This server can hold private keys and move funds
Unlike a read-only data server, radiant-mcp-server exposes a full write/signing surface. It can:
Store WIF private keys server-side in a keyring at
~/.radiant-mcp/keyring.json(override withRADIANT_KEYRING_FILE). The file is required to be0600(owner read/write only) on POSIX — the server refuses to load it otherwise.Generate and restore wallets — random keys and BIP39 mnemonics — returning WIF private keys and seed phrases in tool output.
Build, sign, and broadcast transactions — send RXD, batch-pay, and mint / transfer / burn Glyph tokens — using either a transient WIF passed per call or a key referenced by alias from the keyring.
Any agent or client connected to this server can invoke those tools. Treat connecting it like handing over a hot wallet. Read Security & key handling before exposing it beyond loopback.
Related MCP server: AgentWallet MCP Server
Features
59 tools across 12 categories
Read/query tools need no keys. The Keyring, Wallet, and Transactions categories hold or receive private keys and can move funds — see Security & key handling.
Read & query — no private keys
Blockchain (8 tools)
radiant_get_chain_info— Current chain status (height, tip hash, network params)radiant_get_balance— RXD balance for an address (confirmed + unconfirmed)radiant_get_utxos— List unspent outputs for an addressradiant_get_history— Full transaction history for an address (returns all entries — large for active addresses)radiant_get_transaction— Transaction details by txidradiant_get_block_header— Block header by heightradiant_estimate_fee— Fee estimate (ElectrumX estimate + min-relay policy floor)radiant_broadcast_transaction— Broadcast a pre-signed raw tx (no key required, but publishes to the network)
Glyph Tokens (10 tools)
radiant_get_token— Token info by referenceradiant_list_tokens— Tokens held by an addressradiant_get_token_balance— Specific token balance for an addressradiant_search_tokens— Search tokens by name/tickerradiant_get_token_metadata— Full CBOR metadataradiant_get_token_history— Token transaction historyradiant_get_tokens_by_type— Filter tokens by type (FT/NFT/etc.)radiant_validate_protocols— Check whether a Glyph protocol combination is validradiant_parse_glyph_envelope— Decode a Glyph envelope from raw script hexradiant_get_token_utxos— Discover all token UTXOs (and theirtokenRefs) held by an address
dMint Mining (4 tools)
radiant_get_dmint_contracts— List active mineable tokensradiant_get_dmint_contract— Details for one dMint contractradiant_get_dmint_by_algorithm— dMint contracts filtered by mining algorithmradiant_get_most_profitable_dmint— dMint contracts ranked by profitability
WAVE Naming (5 tools)
radiant_resolve_wave_name— Resolve a WAVE name to its zone recordsradiant_check_wave_available— Check name availabilityradiant_wave_reverse_lookup— Names owned by an addressradiant_wave_subdomains— List child names of a WAVE nameradiant_wave_stats— Naming-system statistics
DEX / Swap (2 tools)
radiant_get_swap_orders— Open swap orders for a pair (on-chain orderbook)radiant_get_swap_history— Trade history for a token
Connection & Monitoring (3 tools)
radiant_connection_health— ElectrumX connection status and latencyradiant_reconnect— Force a fresh ElectrumX reconnect when the session is wedgedradiant_watch_address— Subscribe to real-time payment notifications for an address (ElectrumX scripthash subscription)
Utility / Reference (2 tools)
radiant_get_protocol_info— Glyph protocol type referenceradiant_validate_address— Validate an address; show its type (P2PKH/P2SH) and scripthash
Script Tools — offline (2 tools)
radiant_decode_script— Decode raw script hex into human-readable opcodes (no network)radiant_compile_script— Compile RadiantScript (.cash/.rxd) source into a deployment artifact (ABI, ASM, hex). Offline; requires therxdccompiler binary (setRXDC_PATH, or keep the RadiantScript repo as a sibling directory)
On-Chain AI Primitives (9 tools)
radiant_create_inference_proof— blake3 inference-proof commitmenthash(modelHash ‖ inputHash ‖ output)radiant_verify_inference_proof— Verify an inference-proof commitment off-chainradiant_build_agent_profile— Build an AI-agent identity profile (+ WAVE zone records) with a blake3 commitmentradiant_resolve_agent_identity— Resolve an agent's identity (capabilities, pricing, API endpoint) from its WAVE nameradiant_check_token_access— Token-gated access check (does an address hold the minimum balance?)radiant_open_channel— Build initial state for a micropayment channelradiant_update_channel— Update channel state (transfer photons payer → payee)radiant_build_data_asset— Build Glyph NFT metadata for a data-marketplace assetradiant_search_data_assets— Search the data marketplace (datasets, models, etc.)
These AI primitives compute commitments/metadata or read chain state — they do not hold keys or broadcast. Use the Transactions tools below to publish their output on-chain.
Write & signing — private keys involved
🔑 The next three categories are the security-relevant surface. See Security & key handling.
Keyring — server-side WIF storage (3 tools)
radiant_register_key— Store a WIF private key under an alias in the server-side keyring (~/.radiant-mcp/keyring.json,0600). Lets signing tools reference the key bykey_aliasinstead of resending the WIF on every callradiant_list_keys— List registered aliases and their derived addresses (WIFs are never returned)radiant_remove_key— Remove an alias from the keyring
Wallet — key generation & derivation (3 tools)
radiant_create_wallet— Generate a new wallet (random key, or BIP39 mnemonic with BIP32 HD derivation). Returns the WIF and, if requested, the mnemonicradiant_restore_wallet— Restore a wallet from a BIP39 mnemonic. Returns the derived WIFradiant_derive_address— Derive an address / public key / WIF from a mnemonic + BIP32 path (per-task sub-wallets)
Transactions — build, sign & broadcast (8 tools)
Each accepts either a transient wif (sent through the transport) or a key_alias from the keyring. Unless noted, these sign and broadcast.
radiant_send_rxd— Send RXD: select coins, build, sign, broadcast 🔑radiant_send_batch— Send RXD to up to 100 recipients in one transaction 🔑radiant_transfer_token— Transfer a Glyph FT/NFT to another address 🔑radiant_burn_token— Permanently burn a Glyph token (Glyph protocol 6) 🔑radiant_create_ft— Mint a Glyph Fungible Token (2-tx commit+reveal) 🔑radiant_create_nft— Mint a Glyph NFT (2-tx commit+reveal) 🔑radiant_build_transaction— Build and sign a transaction in dry-run mode; returns raw hex/fee/size without broadcasting (setdry_run=falseto broadcast). Inspect before committing high-value txs 🔑radiant_estimate_tx_fee— Estimate fee from input/output counts (pure arithmetic — no key, no network, no broadcast)
10 Resources
Static reference data (6)
radiant://docs/chain-overview— Blockchain overviewradiant://docs/opcodes— Opcode reference (including V2)radiant://docs/protocols— Glyph protocols, dMint algorithms, DAA modesradiant://docs/network-params— Network parameters (JSON)radiant://docs/sdk-quickstart— radiantjs quick-start guideradiant://docs/knowledge-base— Comprehensive AI knowledge base
Dynamic / live data (4)
radiant://chain/status— Live chain status (height, tip hash, sync state)radiant://dmint/active— Currently active dMint contractsradiant://network/fees— Fee estimates for several confirmation targetsradiant://tokens/popular— Popular fungible tokens and NFT collections
Transports
The same 59 tools and 10 resources are exposed over three transports (all driven by the single source of truth in src/register-tools.ts):
Transport | Entry | Start | Default bind |
stdio (MCP) |
|
| local process (used by Windsurf, Claude Desktop, Cursor) |
REST (HTTP) |
|
|
|
SSE (MCP over HTTP) |
|
|
|
REST API
A standard REST API mirrors the tools for any HTTP client. Key-handling endpoints (/keyring/*, /wallet/*, /tx/*, /token/*) are auth-gated — see Security & key handling.
# Start REST server
npm run start:rest
# Query chain info
curl http://localhost:3080/api/chain
# Get address balance
curl http://localhost:3080/api/address/1A1zP1.../balance
# Search tokens
curl http://localhost:3080/api/tokens/search?q=mytoken
# Full endpoint list
curl http://localhost:3080/apiOpenAPI 3.1 spec: docs/openapi.yaml
Security & key handling
This server has a real write surface. The defaults are loopback-only and conservative, but you should understand them before exposing the server.
How private keys reach the server
Transient WIF — pass
wifon each signing call. It travels through the MCP/HTTP transport and may appear in agent transcripts and client logs.Server-side keyring — call
radiant_register_keyonce, then reference the key bykey_aliason later calls. The WIF stays out of subsequent transport/transcripts but is persisted on disk in the keyring file.
The keyring file
Location:
~/.radiant-mcp/keyring.json(override withRADIANT_KEYRING_FILE).Permissions: must be
0600(owner read/write only) on POSIX. The server refuses to load a keyring with looser permissions (chmod 600 <path>to fix), and writes new entries back at0600.Contents: WIF private keys in plaintext JSON. Anyone who can read this file controls the funds.
radiant_list_keysnever returns WIFs, but the file itself does contain them.
Network exposure & auth (REST and SSE)
Both HTTP transports default to loopback (HOST=127.0.0.1) so key-handling tools are not exposed to the LAN by accident.
REST — key-handling endpoints (
/keyring/*,/wallet/create,/wallet/restore,/wallet/derive,/tx/send,/tx/build,/tx/send-batch,/token/create/ft,/token/create/nft,/token/transfer,/token/burn) are wrapped in an auth check:RADIANT_API_TOKENset → those endpoints requireAuthorization: Bearer <token>.RADIANT_API_TOKENunset → those endpoints are loopback-only (127.0.0.1/::1); non-loopback requests get401.This holds even if you set
HOST=0.0.0.0— key endpoints stay locked down until a token is configured. Read-only endpoints are not token-gated, so binding to0.0.0.0exposes read queries to the network.
SSE — binds loopback by default and logs a warning if
HOSTis non-loopback, because the SSE transport exposes the WIF-handling tools. Put an authenticated reverse proxy in front before allowing remote access.
To expose write endpoints remotely: set RADIANT_API_TOKEN to a strong secret, set HOST=0.0.0.0 (ideally behind a TLS-terminating reverse proxy), and send the bearer token on every key-handling request.
Safety switch
Set RADIANT_TEST_MODE (to any value other than 0/false) to block real broadcasts — radiant_broadcast_transaction and the signing tools will refuse to publish. Useful for dry runs and CI.
Installation
npm install
npm run buildConfiguration
Windsurf / Cascade
Add to your MCP settings (~/.codeium/windsurf/mcp_config.json):
{
"mcpServers": {
"radiant": {
"command": "node",
"args": ["/path/to/radiant-mcp-server/dist/index.js"],
"env": {
"ELECTRUMX_HOST": "electrumx.radiantcore.org",
"RADIANT_NETWORK": "mainnet"
}
}
}
}⚠️ This launches the full server, including the keyring, wallet, and signing tools. Any key registered via
radiant_register_keyis written to~/.radiant-mcp/keyring.jsonand is usable by the agent on every subsequent call. Only connect it in an environment you trust to act on those funds.
Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"radiant": {
"command": "node",
"args": ["/path/to/radiant-mcp-server/dist/index.js"],
"env": {
"ELECTRUMX_HOST": "electrumx.radiantcore.org"
}
}
}
}Environment Variables
Variable | Default | Description |
|
| Connect over secure WebSocket ( |
|
| ElectrumX server hostname |
|
| ElectrumX server port |
|
| Use TLS for a raw socket (ignored when |
|
| Network: |
|
| Bind address for the REST and SSE servers (loopback by default) |
|
| REST API port (also the SSE fallback port) |
|
| SSE server port |
|
| CORS allowed origin (REST) |
| (unset) | Bearer token required for key-handling REST endpoints. When unset, those endpoints are loopback-only |
|
| Path to the server-side keyring (must be |
| (unset) | When set (and not |
|
| Value formatting in responses: |
| (auto-detected) | Path to the |
Development
# MCP server (development)
npm run dev
# REST API server (development)
npm run dev:rest
# SSE server (development)
npm run dev:sse
# Type check
npm run lint
# Build
npm run build
# Run tests
npx tsx test/smoke.ts # MCP smoke test (no network)
npx tsx test/live.ts # MCP live test (ElectrumX)
npx tsx test/rest.ts # REST API test (ElectrumX)Architecture
AI Agent (Windsurf/Claude/Cursor) Web App / HTTP Client
│ MCP Protocol (stdio / SSE) │ HTTP/REST
▼ ▼
radiant-mcp-server (index.ts / sse.ts) radiant-rest-api (rest.ts)
├── Tools (59) ├── REST endpoints
├── Resources (10) ├── OpenAPI 3.1 spec
│ └── bearer-token / loopback auth
├── Keyring (~/.radiant-mcp, 0600) ─────────────┤ (key-handling tools)
└──────────┬────────────────────────────────────┘
│ Shared ElectrumX Client (TCP/TLS)
▼
RXinDexer / ElectrumX
(Glyph + WAVE + Swap + dMint APIs)All transports register the same tools/resources via src/register-tools.ts.
About Radiant
Radiant (RXD) is a Layer 1 UTXO proof-of-work blockchain with native digital asset support. Key features:
SHA512/256d mining algorithm
Glyph token standard (FT, NFT, dMint, WAVE names, 11 protocol types)
256 MB blocks, 5 minute block time
21 billion max supply
V2 opcodes (block 410,000+): OP_BLAKE3, OP_K12, OP_LSHIFT, OP_RSHIFT, OP_2MUL, OP_2DIV
License
MIT
Available Tools
59 toolsradiant_broadcast_transactionC
Broadcast a signed raw transaction to the Radiant network
Inputs: raw_tx (required).
radiant_build_agent_profileA
Build an AI agent identity profile with blake3 commitment, suitable for on-chain registration via the AgentIdentity contract and WAVE naming system.
Inputs: address (required), description (required), capabilities (required), model, +3 more.
radiant_build_data_assetC
Build Glyph NFT metadata for a data marketplace asset (DataMarketplace contract pattern). Returns CBOR-ready metadata structure.
Inputs: ref (required), name (required), type (required), price (required), +6 more.
radiant_build_transactionA
Build and sign a transaction in dry-run mode — returns the raw hex, fee, and size WITHOUT broadcasting. Critical for high-value operations: inspect the transaction before committing. Set dry_run=false to also broadcast after building.
Inputs: outputs (required), wif, dry_run, key_alias, +2 more.
radiant_burn_tokenA
Permanently burn (destroy) a Glyph token using protocol 6 (explicit burn). Spends the token UTXO into an OP_FALSE OP_RETURN output with a Glyph burn envelope. Use this to retire tokens cleanly — the burn is recorded on-chain and verifiable. Requires a WIF private key.
Inputs: amount (required), token_ref (required), wif, key_alias, +2 more.
radiant_check_token_accessA
Check if an address holds sufficient Glyph tokens to access a gated service (TokenGatedService contract pattern).
Inputs: address (required), token_ref (required), min_balance (required).
radiant_check_wave_availableA
Check if a WAVE name is available for registration
Inputs: name (required).
radiant_compile_scriptA
Compile RadiantScript (.cash/.rxd) source code into a deployment artifact. Returns ABI, ASM bytecode, and hex. Works offline — requires the rxdc compiler binary (set RXDC_PATH env var or ensure RadiantScript repo is a sibling directory).
Inputs: source (required), debug, format.
radiant_connection_healthB
Check ElectrumX connection health: latency, connection status, and server info
Inputs: no named parameters.
radiant_create_ftA
Mint a new Glyph Fungible Token (FT) on Radiant. Uses the 2-transaction commit+reveal pattern. Returns both transaction IDs and the token reference (tokenRef) for future transfers. Requires a WIF private key.
Inputs: name (required), supply (required), ticker (required), wif, +6 more.
radiant_create_inference_proofA
Create a blake3 inference proof commitment: hash(modelHash || inputHash || output). Used to record AI inference results on-chain via the InferenceProof contract.
Inputs: input_hash (required), model_hash (required), output_hex (required).
radiant_create_nftA
Mint a new Glyph Non-Fungible Token (NFT) on Radiant. Uses the 2-transaction commit+reveal pattern. Returns both transaction IDs and the token reference (tokenRef). Requires a WIF private key.
Inputs: name (required), wif, image, key_alias, +4 more.
radiant_create_walletA
Generate a new Radiant wallet. Supports two modes: (1) random key (fast, no mnemonic) or (2) BIP39 mnemonic with BIP32 HD derivation (12-24 words, recoverable). WARNING: Store the WIF/mnemonic securely.
Inputs: path, network, mnemonic, passphrase, +1 more.
radiant_decode_scriptA
Decode raw script hex into human-readable opcodes. Works offline — no ElectrumX connection required. Useful for debugging transactions and smart contracts.
Inputs: script_hex (required).
radiant_derive_addressA
Derive a Radiant address from a BIP39 mnemonic and BIP32 derivation path. Lets agents manage per-task sub-wallets from a single root key. Returns the address, public key, and WIF for the derived key. Use different account/index values to generate isolated sub-wallets.
Inputs: mnemonic (required), path, network, passphrase.
radiant_estimate_feeA
Estimate transaction fee for confirmation within N blocks. Returns both the ElectrumX estimate (RXD/kB) and the network's min-relay policy floor (photons/byte) — pay max(estimate, floor).
Inputs: blocks.
radiant_estimate_tx_feeA
Estimate transaction fee in satoshis given input/output counts. Pure arithmetic — no network call. Use this to budget before building a transaction. Supports OP_RETURN outputs (e.g., for token minting).
Inputs: input_count (required), output_count (required), fee_per_byte, op_return_sizes.
radiant_get_balanceA
Get RXD balance for a Radiant address (confirmed and unconfirmed, in both satoshis and RXD)
Inputs: address (required).
radiant_get_block_headerB
Get block header information by block height
Inputs: height (required).
radiant_get_chain_infoA
Get current Radiant blockchain status: latest block height, tip hash, and network parameters
Inputs: no named parameters.
radiant_get_dmint_by_algorithmA
Get dMint contracts filtered by mining algorithm
Inputs: algorithm (required).
radiant_get_dmint_contractA
Get details for a specific dMint contract (difficulty, reward, algorithm, supply)
Inputs: ref (required).
radiant_get_dmint_contractsB
List active dMint (decentralized mining) contracts — mineable tokens with PoW distribution
Inputs: format.
radiant_get_historyA
Get transaction history for a Radiant address. Returns ALL entries (no pagination at this layer) — for very active addresses, expect a large response.
Inputs: address (required).
radiant_get_most_profitable_dmintA
Get dMint contracts sorted by estimated profitability (reward/difficulty ratio)
Inputs: limit.
radiant_get_protocol_infoA
Get information about all Glyph protocol types (IDs, names, descriptions, valid combinations)
Inputs: no named parameters.
radiant_get_swap_historyC
Get trade history for a token on the on-chain DEX
Inputs: ref (required), limit, offset.
radiant_get_swap_ordersA
Get open swap orders for a trading pair (on-chain DEX orderbook). PAGINATION CAVEAT: offset-based — orders move in and out of the book as trades execute, so paging may double-count or miss orders. Re-fetch from offset=0 for a fresh snapshot.
Inputs: buy_ref (required), sell_ref (required), limit, offset.
radiant_get_tokenB
Get Glyph token information by token reference (txid:vout or txid_vout format)
Inputs: token_ref (required).
radiant_get_token_balanceA
Get balance of a specific Glyph token for an address
Inputs: address (required), token_ref (required).
radiant_get_token_historyA
Get transaction history for a specific Glyph token. PAGINATION CAVEAT: offset-based — entries shift if new transactions land between calls, so paging the same series may yield duplicates or gaps. For stable enumeration, fetch in a single call when count is bounded.
Inputs: token_ref (required), limit, offset.
radiant_get_token_metadataB
Get full CBOR metadata for a Glyph token (name, description, image, attributes, etc.)
Inputs: token_ref (required).
radiant_get_tokens_by_typeA
Get tokens filtered by type (FT, NFT, etc.). PAGINATION CAVEAT: offset-based — entries shift if new tokens are minted between calls, so consecutive pages may double-count or miss entries.
Inputs: token_type (required), limit, offset.
radiant_get_token_utxosA
Discover all Glyph tokens held by an address. Returns each token's UTXO reference (tokenRef), txid, vout, height, and satoshi value. Agents can use this to discover what they hold without prior knowledge of token references, then pass tokenRef directly to radiant_transfer_token or radiant_burn_token.
Inputs: address (required).
radiant_get_transactionA
Get detailed information about a transaction by its txid
Inputs: txid (required).
radiant_get_utxosA
List unspent transaction outputs (UTXOs) for a Radiant address
Inputs: address (required).
radiant_list_keysA
List aliases registered in the server-side keyring. WIFs are never returned — only the alias, derived address, and the time the entry was added.
Inputs: no named parameters.
radiant_list_tokensA
List Glyph tokens held by a Radiant address. PAGINATION CAVEAT: this uses simple limit-based truncation; if the holder owns more than limit tokens, the cut-off is non-deterministic. Set limit high enough to cover the holdings, or fetch in a single call when count is bounded.
Inputs: address (required), limit.
radiant_open_channelC
Create initial state for a micropayment channel between two agents (MicropaymentChannel contract pattern).
Inputs: agent_a (required), agent_b (required), capacity (required), channel_id (required), +1 more.
radiant_parse_glyph_envelopeB
Parse a Glyph envelope from raw script hex (decode token metadata from a transaction output)
Inputs: script_hex (required).
radiant_reconnectA
Force a fresh ElectrumX reconnect. Use this when the auto-reconnect logic has given up (after 5 backoff attempts) and the session is wedged. Tears down the existing socket, clears the backoff counter, and re-handshakes.
Inputs: no named parameters.
radiant_register_keyA
Store a WIF private key in the server-side keyring under an alias. Subsequent signing tools can reference the key by key_alias instead of resending the WIF on every call — keeps the WIF out of the MCP transport, agent transcripts, and client logs. The keyring lives at RADIANT_KEYRING_FILE (default ~/.radiant-mcp/keyring.json) and is required to be 0600 mode on POSIX.
Inputs: wif (required), alias (required), overwrite.
radiant_remove_keyA
Remove an alias from the server-side keyring. Returns success even if the alias didn't exist; check the removed field to tell.
Inputs: alias (required).
radiant_resolve_agent_identityB
Resolve an AI agent's identity from its WAVE name. Returns parsed capabilities, pricing, and API endpoint.
Inputs: wave_name (required).
radiant_resolve_wave_nameA
Resolve a WAVE name to its zone records (address, avatar, description, DNS records, etc.). WAVE is Radiant's on-chain naming system.
Inputs: name (required).
radiant_restore_walletA
Restore a Radiant wallet from a BIP39 mnemonic phrase. Validates the mnemonic checksum and derives the private key via BIP32 HD derivation.
Inputs: mnemonic (required), path, network, passphrase.
radiant_search_data_assetsA
Search the data marketplace for datasets, models, and other data assets (NFTs with DAT protocol).
Inputs: query (required), type, limit.
radiant_search_tokensA
Search for Glyph tokens by name or ticker symbol. Returns up to limit matches in a single response (no offset/cursor support upstream — set limit to cover the result set you care about).
Inputs: query (required), limit, protocols.
radiant_send_batchA
Send RXD to multiple recipients in a single transaction. Much cheaper than N separate transactions — inputs are selected once and change is returned in a single output. Ideal for agent fan-out payments (e.g., paying multiple service providers).
Inputs: outputs (required), wif, key_alias, fee_per_byte, +1 more.
radiant_send_rxdA
Send RXD (photons) to an address. Fetches UTXOs, selects coins, builds, signs, and broadcasts the transaction. Requires a WIF private key for the sender address.
Inputs: satoshis (required), to_address (required), wif, key_alias, +2 more.
radiant_transfer_tokenA
Transfer a Glyph token (FT or NFT) to another address. The token UTXO must be at the sender's address. For FTs provide the amount in base units; for NFTs use amount=1. Requires a WIF private key.
Inputs: amount (required), token_ref (required), to_address (required), wif, +3 more.
radiant_update_channelC
Update a micropayment channel state: transfer photons from payer (agentA) to payee (agentB).
Inputs: nonce (required), agent_a (required), agent_b (required), capacity (required), +5 more.
radiant_validate_addressA
Validate a Radiant address and show its type (P2PKH or P2SH)
Inputs: address (required).
radiant_validate_protocolsA
Validate a Glyph protocol combination (check if protocol IDs can be used together)
Inputs: protocols (required).
radiant_verify_inference_proofA
Verify an inference proof commitment off-chain. Checks that blake3(modelHash || inputHash || output) matches the expected commitment.
Inputs: commitment (required), input_hash (required), model_hash (required), output_hex (required).
radiant_watch_addressA
Subscribe to real-time payment notifications for a Radiant address via ElectrumX scripthash subscription. Returns the current status hash and subscribes to future changes. Notifications arrive as ElectrumX push events (blockchain.scripthash.subscribe). Use this instead of polling for payment detection.
Inputs: address (required).
radiant_wave_reverse_lookupB
Find WAVE names owned by a Radiant address
Inputs: address (required), limit.
radiant_wave_statsB
Get WAVE naming system statistics (total names, cache size, etc.)
Inputs: no named parameters.
radiant_wave_subdomainsA
List subdomains (child names) of a WAVE name. PAGINATION CAVEAT: offset-based — entries shift if new subdomains are registered between calls.
Inputs: parent_name (required), limit, offset.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 59 tools
Most tools name both the resource and action (get_balance, transfer_token, resolve_wave_name), so the primary purpose is easy to pick. The main ambiguities are fee estimation (estimate_fee vs estimate_tx_fee) and the build/send/broadcast transaction cluster, but the descriptions draw enough of a boundary that an agent can choose correctly.
The surface consistently uses a radiant_ snake_case prefix with verb_noun names. Minor deviations such as connection_health (no verb), reconnect (bare verb), and a mix of get/list/search/resolve for read operations keep it from being perfectly uniform.
At 59 tools, this server is above the 50+ extreme threshold and far past the 25+ 'too many' boundary. It bundles multiple distinct domains (core chain, Glyph tokens, WAVE, DEX, AI agent contracts, wallet/keyring) into one surface and would be far more navigable split into focused MCP servers.
Core RXD and Glyph token lifecycles are well covered: create, transfer, burn, balance, history, and UTXO discovery all exist. However, several subdomains are half-finished: WAVE has availability/resolution but no registration or renewal, the DEX has orders/history but no create/cancel/trade, and channels have open/update but no close/settle.
Maintenance
Related MCP Connectors
Provide AI agents and automation tools with contextual access to blockchain data including balance…
AI Agent Utility Layer for agent safety, web monitoring, crypto research and tool discovery.
ERC-8004 agent identity, on-chain subscriptions, reputation, A2A tasks and chat over 53 tools.
Pay-per-call on-chain data for AI agents: token, wallet, risk, whale, NFT, tx. No API keys.
Related MCP Servers
- AlicenseCqualityDmaintenanceEnables AI agents to interact with cryptocurrency ecosystems through wallet management, trading operations (swaps, DCA, limit orders), staking, and multi-chain support starting with Solana.37GPL 3.0
- AlicenseBqualityBmaintenanceProvides permissionless wallet infrastructure for AI agents to manage wallets, sign transactions, and handle tokens across Solana and all EVM-compatible chains. It includes 29 specialized tools for on-chain operations, featuring built-in security guards and automated x402 payment processing without KYC requirements.40399 npm3MIT

Bink MCP Serverofficial
AlicenseNot gradedqualityDmaintenanceEnables AI agents to perform blockchain operations like wallet management, token info, DeFi swaps, cross-chain bridging, and price checking across Ethereum, BNB Chain, and Solana.ISC- AlicenseNot gradedqualityDmaintenanceEnables AI agents to interact with the GIWA blockchain, including balance queries, contract interactions, Flashblocks preconfirmations, Dojang attestations, and UP ID resolution.MIT