42 MCP Tools Categorized: Wallet, Transfer, DeFi, NFT, and Utility Commands for Claude

2026-05-07

MCP tools enable Claude to interact with real blockchain networks, but most servers focus on read-only data like token prices or NFT metadata. WAIaaS provides 45 MCP tools that let your Claude agent actually execute transactions — swap tokens on Jupiter, stake with Lido, bridge across chains, and manage NFT collections with real wallet functionality.

Why MCP Native Wallet Tools Matter

Claude Desktop's Model Context Protocol transforms how AI agents interact with external systems. Instead of copying and pasting wallet addresses or manually executing trades, your agent can directly manage crypto operations through structured tool calls. This bridges the gap between AI reasoning and blockchain execution.

The challenge is that blockchain interactions require more than just API calls — they need wallet management, transaction signing, policy enforcement, and multi-chain support. Building this infrastructure from scratch for each MCP server creates fragmentation and security risks.

WAIaaS: The MCP Wallet Server

WAIaaS runs as an MCP server that provides 45 tools across 5 categories: wallet management, token transfers, DeFi protocols, NFT operations, and utility functions. Each tool handles the complexity of blockchain interactions while presenting a clean interface to Claude.

Here's how the tools break down:

Wallet Tools (8 tools):

get-balance — Check native token balance
get-address — Get wallet address
get-assets — List all token balances
get-wallet-info — Wallet metadata and chain info
list-credentials — Available signing methods
get-nonce — Current transaction nonce
resolve-asset — Convert symbols to contract addresses
get-tokens — Supported token registry

Transfer Tools (7 tools):

send-token — Native and token transfers
transfer-nft — NFT transfers with metadata
send-batch — Multiple transactions atomically
approve-token — ERC-20 approve operations
sign-transaction — Sign arbitrary transactions
sign-message — Message signing for authentication
simulate-transaction — Dry-run before execution

DeFi Tools (12 tools):

action-provider — List available DeFi protocols
get-defi-positions — Current lending/staking positions
get-health-factor — Liquidation risk metrics
hyperliquid — Perpetual futures trading
polymarket — Prediction market positions
get-provider-status — Protocol availability and gas costs

NFT Tools (4 tools):

list-nfts — Owned NFT collection
get-nft-metadata — Metadata with image caching
transfer-nft — Move NFTs between wallets

Utility Tools (14 tools):

x402-fetch — HTTP requests with automatic crypto payments
call-contract — Smart contract interactions
encode-calldata — ABI encoding for contract calls
get-transaction — Transaction details and status
list-transactions — Wallet history
erc8004-get-agent-info — Onchain agent reputation
build-userop — ERC-4337 UserOperation construction
wc-connect — WalletConnect pairing for approvals

Quick MCP Setup

Setting up WAIaaS as an MCP server takes three steps:

1. Start the WAIaaS daemon:

npm install -g @waiaas/cli
waiaas init
waiaas start
waiaas quickset --mode mainnet  # Creates wallets + sessions

2. Add to Claude Desktop configuration:

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

3. Restart Claude Desktop — The MCP tools appear automatically in your conversation.

The CLI waiaas mcp setup --all command can automatically register all wallets with Claude Desktop, generating the configuration file for you.

MCP Tools in Action

Once configured, Claude can execute complex onchain workflows through natural conversation. Here's what becomes possible:

Portfolio Management: "Check my wallet balance across all tokens" → Claude calls get-assets and formats the results with USD values and 24h changes.

DeFi Operations: "Swap 0.1 SOL for USDC on Jupiter" → Claude calls the action-provider tool with jupiter-swap parameters, handling slippage and routing automatically.

Cross-Chain Bridging: "Bridge 100 USDC from Ethereum to Polygon" → Claude uses the LI.FI integration to find the best route and execute the bridge transaction.

NFT Management: "Show me my NFT collection" → Claude calls list-nfts and get-nft-metadata to display owned NFTs with images and floor prices.

Risk Management: "What's my liquidation risk on Aave?" → Claude calls get-health-factor to check collateralization ratios across all lending positions.

Multi-Wallet Configuration

For agents managing multiple wallets, you can register separate MCP servers per wallet:

{
  "mcpServers": {
    "waiaas-trading": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
        "WAIAAS_AGENT_NAME": "trading-agent"
      }
    },
    "waiaas-defi": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c4cd2-86e8-758f-a61e-9c560307c788", 
        "WAIAAS_AGENT_NAME": "defi-positions"
      }
    }
  }
}

This gives Claude context about which wallet to use for specific operations — trading strategies on one wallet, DeFi positions on another.

Security Through MCP

WAIaaS implements a 7-stage transaction pipeline that processes every MCP tool call: validation, authentication, policy enforcement, time delays, execution, and confirmation. This happens transparently behind the MCP interface.

The policy engine supports 21 policy types with 4 security tiers:

INSTANT — Small amounts execute immediately
NOTIFY — Medium amounts execute with notifications
DELAY — Large amounts wait 15 minutes (cancellable)
APPROVAL — Very large amounts require human approval

Claude sees a simple tool interface, but every transaction follows enterprise-grade security controls.

Advanced MCP Patterns

x402 Payments: The x402-fetch tool enables Claude to make HTTP requests that automatically pay for API access with cryptocurrency. This unlocks premium data feeds, AI model inference, and other paid services without manual payment flows.

# Claude can do this automatically:
# 1. Make API request → receives 402 Payment Required
# 2. Pay invoice with wallet funds  
# 3. Retry request with payment proof
# 4. Return data to user

Smart Contract Interactions: The call-contract and encode-calldata tools let Claude interact with any smart contract by constructing the appropriate transaction parameters.

Account Abstraction: The build-userop tool creates ERC-4337 UserOperations for gasless transactions, enabling Claude to execute complex DeFi strategies without the user holding ETH for gas.

Quick Start

Install and start WAIaaS:

npm install -g @waiaas/cli
waiaas init && waiaas start
waiaas quickset --mode mainnet

Auto-configure Claude Desktop:

waiaas mcp setup --all

Restart Claude Desktop and ask: "What's my wallet balance?"
Test a transaction: "Send 0.001 ETH to [address]"
Try DeFi: "What are my current DeFi positions across all protocols?"

The MCP tools handle all blockchain complexity — Claude just sees clean, typed function calls that return structured data.

Ready to give your Claude agent onchain superpowers? Check out the GitHub repository for complete installation instructions, or visit waiaas.ai to explore the full feature set.

What's Next

Once you've connected Claude to WAIaaS through MCP, explore advanced features like policy configuration for automated risk management, multi-chain portfolio tracking, and x402 payments for premium API access. The 45 MCP tools provide the foundation for sophisticated onchain agent workflows that previously required custom integration work.