All 45 MCP Tools Explained: Complete Reference for Claude AI Agents

2026-05-01

MCP tools transform Claude from a text-only assistant into an agent capable of executing onchain transactions, managing DeFi positions, and handling cryptocurrency operations. WAIaaS provides 45 specialized MCP tools that integrate seamlessly with Claude Desktop, giving your AI agent comprehensive blockchain capabilities without requiring custom integrations or complex setup.

Why MCP Integration Matters for AI Agents

Most AI agents can only read blockchain data or generate transaction code that humans must execute manually. This creates a frustrating gap between what the agent knows and what it can actually do. The Model Context Protocol (MCP) bridges this gap by providing a standardized way for Claude to call external tools directly.

With WAIaaS MCP integration, Claude can check wallet balances, execute DeFi swaps, manage lending positions, transfer NFTs, and even handle micropayments for API calls — all autonomously within the conversation. This transforms Claude from a helpful advisor into an active participant in your onchain workflows.

Complete MCP Tool Reference

WAIaaS provides 45 MCP tools organized into five categories. Here's the complete reference:

Wallet Management Tools

get-balance — Returns native token balance and USD value

# What Claude sees when you ask "What's my balance?"
{
  "balance": "2.5",
  "symbol": "SOL", 
  "usd_value": 425.50,
  "chain": "solana",
  "network": "mainnet"
}

get-address — Get wallet's public address get-wallet-info — Complete wallet metadata including creation date and chain get-assets — List all token holdings with balances and USD values get-tokens — Available tokens for the current network list-credentials — Show configured RPC endpoints and API keys

Transaction Tools

send-token — Transfer native tokens or SPL/ERC-20 tokens transfer-nft — Transfer NFTs with automatic metadata resolution send-batch — Execute multiple transactions atomically sign-transaction — Sign arbitrary transactions without broadcasting sign-message — Sign messages for authentication or proofs get-transaction — Retrieve transaction details and status list-transactions — Transaction history with filtering options simulate-transaction — Dry-run transactions before execution

Example of Claude using send-token:

# User: "Send 0.1 SOL to Alice"
# Claude calls send-token MCP tool:
{
  "type": "TRANSFER",
  "to": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
  "amount": "0.1"
}

DeFi Integration Tools

get-defi-positions — View lending, staking, and LP positions across all protocols get-health-factor — Current liquidation risk for lending positions action-provider — Execute actions on any of the 15 supported DeFi protocols

The action-provider tool works with these protocols:

jupiter-swap — Solana's best-price DEX aggregator
lido-staking — Ethereum liquid staking
jito-staking — Solana liquid staking
aave-v3 — Cross-chain lending and borrowing
kamino — Solana lending with leveraged strategies
hyperliquid — Perpetual futures trading
polymarket — Prediction market trading
lifi — Cross-chain bridging
across — Fast cross-chain transfers
zerox-swap — Professional-grade DEX trading
pendle — Yield tokenization and trading

Example DeFi interaction:

# User: "Swap 100 USDC for SOL on Jupiter"
# Claude calls action-provider with jupiter-swap:
{
  "provider": "jupiter-swap",
  "action": "swap",
  "params": {
    "inputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "outputMint": "So11111111111111111111111111111111111111112", 
    "amount": "100000000"
  }
}

Policy and Security Tools

get-policies — View active spending limits and security rules approve-token — Approve ERC-20 token spending for DeFi protocols get-provider-status — Check if DeFi providers are operational

Advanced Protocol Tools

build-userop — Create ERC-4337 UserOperations for gasless transactions sign-userop — Sign UserOperations for Account Abstraction call-contract — Execute arbitrary smart contract calls encode-calldata — Generate transaction calldata for contracts get-nonce — Get current transaction nonce resolve-asset — Resolve token symbols to addresses

Web3 Authentication Tools

erc8128-sign-request — Sign HTTP requests with wallet for API authentication erc8128-verify-signature — Verify ERC-8128 HTTP signatures wc-connect, wc-disconnect, wc-status — WalletConnect session management

Reputation and Trust Tools

erc8004-get-agent-info — Retrieve onchain agent metadata erc8004-get-reputation — Check agent reputation score erc8004-get-validation-status — Verify agent trustworthiness

NFT Tools

list-nfts — Show all NFTs in wallet with metadata get-nft-metadata — Detailed NFT information and attributes

Network and Infrastructure Tools

get-rpc-proxy-url — Get proxied RPC endpoints for better reliability list-sessions — Active AI agent sessions list-incoming-transactions — Monitor incoming transfers get-incoming-summary — Summary of recent deposits list-offchain-actions — Pending transactions requiring approval

Micropayment Tools

x402-fetch — HTTP requests with automatic cryptocurrency payment for 402 Payment Required responses

Example of Claude using x402-fetch:

# User: "Get premium market data from that paid API"
# Claude calls x402-fetch, automatically pays the microfee, gets the data
{
  "url": "https://api.example.com/premium-data",
  "method": "GET",
  "auto_pay": true,
  "max_payment_usd": 0.10
}

Quick Setup Guide

Here's how to connect Claude Desktop to WAIaaS:

Step 1: Start WAIaaS daemon

npm install -g @waiaas/cli
waiaas quickstart

Step 2: Create a session for Claude

waiaas quickset --mode mainnet
# Creates wallets + MCP sessions, prints config

Step 3: Add to Claude Desktop config Open ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_eyJhbGciOiJIUzI1NiJ9...",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

Step 4: Restart Claude Desktop and test Ask Claude: "What's my wallet balance?" You should see your actual onchain balance with USD values.

Step 5: Set up security policies

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <your-password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT", 
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 300
    }
  }'

Real-World Usage Examples

With all 45 MCP tools available, Claude can handle sophisticated onchain workflows:

Portfolio Management: "Show me my DeFi positions across all protocols and suggest rebalancing opportunities"

Claude calls get-defi-positions, analyzes yield rates, suggests optimal allocation

Cross-Chain Operations: "Bridge 500 USDC from Ethereum to Arbitrum using the cheapest route"

Claude calls action-provider with lifi, compares bridge costs, executes optimal route

Automated Trading: "If SOL drops below $100, swap half my SOL for USDC"

Claude monitors prices, uses simulate-transaction for safety, executes conditional swaps

NFT Management: "List my NFTs by floor price and transfer the least valuable one to my cold wallet"

Claude calls list-nfts, fetches floor prices, identifies target NFT, executes transfer

Micropayment Workflows: "Get the latest research report from three different crypto data providers"

Claude uses x402-fetch to automatically pay for premium API access across multiple services

The key advantage is that Claude sees all wallet state, understands DeFi protocols, and can execute multi-step operations autonomously while respecting your security policies.

Ready to give your Claude agent onchain superpowers? Get started at GitHub or visit the official documentation to explore advanced configuration options.

What's Next

These 45 MCP tools provide the foundation for sophisticated AI agent workflows. Explore advanced patterns like multi-wallet strategies, automated yield farming, and cross-protocol arbitrage as you build more complex onchain agents.