Get current Radiant blockchain status: latest block height, tip hash, and network parameters

Get RXD balance for a Radiant address (confirmed and unconfirmed, in both satoshis and RXD)

List unspent transaction outputs (UTXOs) for a Radiant address

Get transaction history for a Radiant address. Returns ALL entries (no pagination at this layer) — for very active addresses, expect a large response.

Get detailed information about a transaction by its txid

Get block header information by block height

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).

Broadcast a signed raw transaction to the Radiant network

Get Glyph token information by token reference (txid:vout or txid_vout format)

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.

Get balance of a specific Glyph token for an address

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).

Get full CBOR metadata for a Glyph token (name, description, image, attributes, etc.)

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.

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.

Validate a Glyph protocol combination (check if protocol IDs can be used together)

Parse a Glyph envelope from raw script hex (decode token metadata from a transaction output)

List active dMint (decentralized mining) contracts — mineable tokens with PoW distribution

Get details for a specific dMint contract (difficulty, reward, algorithm, supply)

Get dMint contracts filtered by mining algorithm

Get dMint contracts sorted by estimated profitability (reward/difficulty ratio)

Resolve a WAVE name to its zone records (address, avatar, description, DNS records, etc.). WAVE is Radiant's on-chain naming system.

Check if a WAVE name is available for registration

Find WAVE names owned by a Radiant address

List subdomains (child names) of a WAVE name. PAGINATION CAVEAT: offset-based — entries shift if new subdomains are registered between calls.

Get WAVE naming system statistics (total names, cache size, etc.)

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.

Get information about all Glyph protocol types (IDs, names, descriptions, valid combinations)

Validate a Radiant address and show its type (P2PKH or P2SH)

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.

List aliases registered in the server-side keyring. WIFs are never returned — only the alias, derived address, and the time the entry was added.

Remove an alias from the server-side keyring. Returns success even if the alias didn't exist; check the removed field to tell.

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.

Restore a Radiant wallet from a BIP39 mnemonic phrase. Validates the mnemonic checksum and derives the private key via BIP32 HD derivation.

Get trade history for a token on the on-chain DEX

Check ElectrumX connection health: latency, connection status, and server info

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.

Create a blake3 inference proof commitment: hash(modelHash || inputHash || output). Used to record AI inference results on-chain via the InferenceProof contract.

Verify an inference proof commitment off-chain. Checks that blake3(modelHash || inputHash || output) matches the expected commitment.

Build an AI agent identity profile with blake3 commitment, suitable for on-chain registration via the AgentIdentity contract and WAVE naming system.

Resolve an AI agent's identity from its WAVE name. Returns parsed capabilities, pricing, and API endpoint.

Check if an address holds sufficient Glyph tokens to access a gated service (TokenGatedService contract pattern).

Create initial state for a micropayment channel between two agents (MicropaymentChannel contract pattern).

Update a micropayment channel state: transfer photons from payer (agentA) to payee (agentB).

Build Glyph NFT metadata for a data marketplace asset (DataMarketplace contract pattern). Returns CBOR-ready metadata structure.

Search the data marketplace for datasets, models, and other data assets (NFTs with DAT protocol).

Decode raw script hex into human-readable opcodes. Works offline — no ElectrumX connection required. Useful for debugging transactions and smart contracts.

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).

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.

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.

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.

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.

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.

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.

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).

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).

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.

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.

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.