MCP Wallet: How AI Agents Access Crypto via Model Context Protocol

MCP Wallet: How AI Agents Access Crypto via Model Context Protocol

The Model Context Protocol (MCP) is changing how AI agents interact with external systems. Instead of screen-scraping, API hacking, or custom integrations, MCP provides a standardized way for AI models to discover and use tools. When those tools include wallet operations, you get an MCP wallet — an AI agent's native interface to the blockchain.

This guide explains what an MCP wallet is, how it works, what operations it supports, and how to set one up with WAIaaS.

What Is an MCP Wallet?

An MCP wallet is a wallet system that exposes blockchain operations as MCP tools. AI agents — like Claude, or any MCP-compatible model — can discover these tools at runtime and use them to:

• Create and manage crypto wallets
• Send native currency and tokens
• Execute DeFi operations (swap, bridge, lend, stake)
• Trade NFTs
• Sign arbitrary messages
• Query balances and transaction history

The key insight is that MCP wallets let AI agents interact with blockchains through a protocol they already understand. There's no need for custom API clients, SDKs, or integration code. The agent discovers the wallet tools via MCP and uses them natively.

MCP in 30 Seconds

MCP (Model Context Protocol) is an open standard developed by Anthropic that defines how AI models connect to external tools and data sources. An MCP server exposes "tools" (functions the AI can call) and "resources" (data the AI can read). The AI model discovers available tools at startup and can invoke them during conversation.

For wallets, this means an AI agent can see tools like send_transaction, swap, bridge, and list_wallets — and use them as naturally as it uses any other capability.

How MCP Wallet Tools Work

WAIaaS provides 42 MCP tools organized by function. Here's how the tool flow works:

Session Management

Before any wallet operation, the agent creates a session:

Tool: create_session
Input: { password: "***" }
Output: { sessionToken: "eyJ...", expiresAt: "..." }

The session token authenticates all subsequent tool calls. Sessions have configurable TTL and the agent can renew them as needed.

Wallet Discovery

The agent discovers available wallets:

Tool: list_wallets
Output: [
  { id: "w_abc123", name: "trading-bot", chains: ["evm", "solana"] },
  { id: "w_def456", name: "defi-agent", chains: ["evm"] }
]

Transaction Execution

The agent executes operations using purpose-built tools:

Tool: send_transaction
Input: {
  walletId: "w_abc123",
  to: "0x1234...",
  value: "0.1",
  chainId: 8453
}
Output: { txHash: "0xabcd...", status: "confirmed" }

DeFi Operations

DeFi tools follow the same pattern — the agent describes the intent and the wallet handles the complexity:

Tool: swap
Input: {
  walletId: "w_abc123",
  fromToken: "USDC",
  toToken: "ETH",
  amount: "100",
  chainId: 8453
}
Output: { txHash: "0x...", amountOut: "0.032", route: "0x DEX" }

All tools go through the same 6-stage transaction pipeline with policy enforcement. The MCP layer is an interface — the security model is identical to REST API access.

MCP vs REST API

WAIaaS supports both MCP and REST API access. Here's when to use each:

Choose MCP when your agent is an MCP-compatible model (Claude, etc.) and you want zero-code integration.

Choose REST API when you're building a custom application, using a non-MCP agent, or need network-accessible wallet operations.

Both interfaces share the same wallet daemon, policy engine, and security model. Switching between them does not affect security.

Supported Operations

The 42 MCP tools cover the full spectrum of wallet operations:

Core Wallet

• create_session / check_session — Authentication
• list_wallets / get_wallet / create_wallet — Wallet management
• get_balance / get_token_balances — Balance queries
• connect_info — Agent self-discovery (capabilities, networks, policies)

Transfers

• send_transaction — Native currency transfers
• send_token — ERC-20 / SPL token transfers
• send_nft — NFT transfers (ERC-721, ERC-1155, Metaplex)

DeFi

• swap — Token swaps (Jupiter on Solana, 0x on EVM, DCent aggregator)
• bridge — Cross-chain bridges (LI.FI, Across Protocol)
• lend_supply / lend_borrow / lend_repay / lend_withdraw — Lending (Aave V3, Kamino)
• stake / unstake — Liquid staking (Lido, Jito)
• perp_open / perp_close / perp_positions — Perpetual futures (Drift, Hyperliquid)
• yield_positions — DeFi position dashboard

Governance and Signing

• sign_message — Arbitrary message signing
• approve_token — ERC-20 token approvals
• call_contract — Generic smart contract calls

Policies and Admin

• list_policies / create_policy — Policy management
• list_sessions — Session management
• get_transaction_history — Transaction logs

Setting Up an MCP Wallet with WAIaaS

Getting an MCP wallet running takes three steps:

Step 1: Install WAIaaS

# Using npm
npx @waiaas/cli init
npx @waiaas/cli start

# Or using Docker
docker run -d -v waiaas-data:/data -p 3420:3420 waiaas/daemon

Step 2: Create a Wallet

Access the Admin Web UI at http://localhost:3420 or use the CLI:

# Set master password on first run
# Then create a wallet through Admin UI or API

Step 3: Configure Claude Desktop

Add WAIaaS to your claude_desktop_config.json:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_URL": "http://localhost:3420"
      }
    }
  }
}

Restart Claude Desktop. The 42 wallet tools are now available. Claude can create sessions, list wallets, send transactions, execute DeFi operations, and manage policies — all through natural conversation.

Example Conversation

You: "Swap 50 USDC for ETH on Base using my trading wallet."

Claude: Uses create_session to authenticate, list_wallets to find the trading wallet, then swap to execute the trade. Returns the transaction hash and amount received.

Frequently Asked Questions

Resources

• Documentation: Architecture | Security Model | API Reference
• GitHub: github.com/minhoyoo-iotrust/WAIaaS
• npm: @waiaas/cli | @waiaas/mcp | @waiaas/sdk
• Docker: waiaas/daemon

Related

• What Is an AI Wallet? — Complete guide to AI wallets, how they work, and their security model.
• Claude Code Integration Guide — Step-by-step guide for integrating WAIaaS with Claude Code.
• Architecture Overview — Technical deep-dive into the 6-stage transaction pipeline and policy engine.