Add One JSON Block: Give Claude Desktop a Multi-Chain Wallet

2026-04-28

One JSON block in your Claude Desktop config gives your agent a multi-chain wallet with 45 tools for DeFi, NFTs, and onchain actions. WAIaaS provides the first MCP server specifically built for blockchain operations, turning Claude into a crypto-native agent in minutes.

Why MCP Changes Everything for Onchain AI

Model Context Protocol (MCP) bridges the gap between AI reasoning and external systems. Claude can analyze, plan, and execute — but it needs tools to interact with blockchains. Without MCP, you're stuck copying wallet addresses and transaction hashes between Claude and your wallet app.

With WAIaaS's MCP integration, Claude directly calls wallet functions, checks DeFi positions, and executes swaps. No more context switching. Your agent becomes truly autonomous onchain.

The One-Line Solution

WAIaaS runs as an MCP server that Claude Desktop connects to automatically. Add this block to your 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_<your-token>",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

That's it. Claude now has 45 MCP tools spanning wallet operations, DeFi protocols, NFT management, and x402 micropayments.

What Claude Can Do After MCP Setup

Once connected, Claude gains access to multi-chain wallet capabilities:

Wallet Operations

DeFi Protocols Claude can interact with 15 integrated protocols:

Advanced Features

Ask Claude: "Check my DeFi positions and rebalance if my Aave health factor is below 2.0"

Claude responds by:

  1. Calling get-defi-positions to fetch lending data
  2. Analyzing health factors across positions
  3. If needed, calling action-provider with Aave repayment actions
  4. Executing transactions through the session-authenticated wallet

Multi-Wallet MCP Configuration

For agents managing multiple wallets, configure separate MCP servers:

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

Each MCP server connects to a different WAIaaS wallet, allowing Claude to manage specialized portfolios with isolated permissions.

Security Through Policy Engine

WAIaaS enforces 21 policy types across 4 security tiers to keep AI agents safe:

Default-deny policies block unauthorized actions. ALLOWED_TOKENS and CONTRACT_WHITELIST policies ensure agents only interact with approved contracts.

Example policy restricting Claude to $100 instant swaps:

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

Quick Start: Claude + Wallet in 5 Steps

  1. Install WAIaaS CLI
npm install -g @waiaas/cli
  1. Initialize and start daemon
waiaas init
waiaas start
waiaas quickset --mode mainnet  # Creates wallets + MCP sessions
  1. Auto-register MCP
waiaas mcp setup --all

  1. Fund your wallet Transfer some ETH/SOL to the generated wallet address.

  2. Test in Claude Desktop Ask Claude: "What's my wallet balance?" and watch it call the MCP tools directly.

The quickset command creates both Ethereum and Solana wallets with MCP sessions, then outputs the exact JSON config for Claude Desktop.

Real-World MCP Use Cases

Portfolio Rebalancing Agent "Check all my DeFi positions. If any protocol has over 40% allocation, rebalance by moving excess to Aave USDC lending."

Claude automatically:

Cross-Chain Arbitrage "Monitor USDC prices on Ethereum vs Solana. If spread exceeds 0.1%, bridge and arbitrage."

Claude uses:

NFT Collection Management "List all my NFTs. If any have floor prices 2x above purchase price, create OpenSea listings."

The MCP tools handle:

Advanced MCP Integration Patterns

WAIaaS MCP servers support complex agent workflows through tool chaining:

Dry-Run Before Execute

// Claude can simulate transactions first
await client.callTool('simulate-transaction', {
  type: 'TRANSFER',
  to: 'recipient-address', 
  amount: '1.0',
  dryRun: true
});
// Then execute if simulation succeeds

Batch Operations

// Group multiple operations into single transaction
await client.callTool('send-batch', {
  transactions: [
    { type: 'APPROVE', spender: 'uniswap-router', amount: '1000' },
    { type: 'CONTRACT_CALL', to: 'uniswap-router', data: '0x...' }
  ]
});

x402 Micropayments

// Claude automatically pays for premium APIs
await client.callTool('x402-fetch', {
  url: 'https://premium-api.com/data',
  method: 'GET'
});
// WAIaaS handles 402 Payment Required responses transparently

What's Next

You've given Claude a multi-chain wallet through MCP, but that's just the beginning. Explore the 39 REST API routes for custom integrations, or try the TypeScript/Python SDKs for building dedicated trading bots.

Ready to make Claude crypto-native? Get WAIaaS from GitHub, or visit the official site for comprehensive documentation and examples.