DEV Community

Cover image for One Config Line: Give Claude Desktop Full Onchain Powers
Wallet Guy
Wallet Guy

Posted on

One Config Line: Give Claude Desktop Full Onchain Powers

#ai #llm #web3 #tutorial

One Config Line: Give Claude Desktop Full Onchain Powers

MCP developers already know the pattern — add a server to your claude_desktop_config.json, restart Claude Desktop, and your agent gains new tools. WAIaaS is an MCP server that hands Claude a fully functional crypto wallet: check balances, send tokens, swap on Jupiter, stake with Lido, bridge across chains, trade perpetuals on Hyperliquid, and 40 more tools — all from a single config entry.

Why This Matters

Claude is remarkably good at reasoning about financial decisions. It can analyze a portfolio, identify an arbitrage opportunity, or know exactly when to rebalance a DeFi position. The missing piece has always been execution — Claude can tell you what to do, but it can't actually do it. MCP bridges that gap conceptually, but until there's an MCP server that speaks blockchain, you're still copying addresses and pasting transactions manually.

That's the problem WAIaaS solves. It's an open-source, self-hosted Wallet-as-a-Service built specifically for AI agents. It exposes 45 MCP tools covering everything from basic balance checks to complex DeFi operations across 18 networks. You host it yourself, your keys stay on your machine, and you control exactly what the agent is allowed to do through a policy engine that runs before any transaction touches the chain.

The Config Entry

Here's what "one line" actually looks like in practice. Open your Claude Desktop config file at ~/Library/Application Support/Claude/claude_desktop_config.json and add this:

{
  "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"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

That's it. Restart Claude Desktop, and Claude now has access to 45 tools covering wallets, transactions, DeFi, NFTs, and x402 payments. The @waiaas/mcp package is pulled via npx — no global install required.

Of course, you need a WAIaaS daemon running locally for this to connect to. Let's get that sorted in about five minutes.

Getting the Daemon Running

WAIaaS ships as a Docker image, which is the fastest way to get started. The entire setup is three commands:

git clone https://github.com/waiaas/WAIaaS.git
cd WAIaaS
docker compose up -d
Enter fullscreen mode Exit fullscreen mode

That starts the daemon on 127.0.0.1:3100, bound to localhost only by default. The daemon is now ready to accept connections.

If you'd rather skip Docker, the CLI path is equally direct:

npm install -g @waiaas/cli
waiaas init
waiaas start
Enter fullscreen mode Exit fullscreen mode

Either way, the next step is creating a wallet and getting a session token for Claude to use.

Creating a Wallet and Session Token

The daemon has three auth roles. The master password is used for admin operations like creating wallets and setting policies. Session tokens are scoped credentials you hand to agents — they can only do what their associated policies allow. The owner role is for the fund owner to approve large transactions.

Create a wallet with masterAuth:

curl -X POST http://127.0.0.1:3100/v1/wallets \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{"name": "trading-wallet", "chain": "solana", "environment": "mainnet"}'
Enter fullscreen mode Exit fullscreen mode

Then create a session for that wallet:

curl -X POST http://127.0.0.1:3100/v1/sessions \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{"walletId": "<wallet-uuid>"}'
Enter fullscreen mode Exit fullscreen mode

The response contains your wai_sess_... token. Drop that into the Claude Desktop config above, restart Claude, and your agent has a wallet.

If you want to skip the manual curl steps entirely, the CLI has a shortcut:

waiaas quickset --mode mainnet
Enter fullscreen mode Exit fullscreen mode

This creates wallets, generates sessions, and prints the exact MCP config JSON to paste into Claude Desktop. For even more automation, waiaas mcp setup --all registers all wallets with Claude Desktop automatically.

What Claude Can Actually Do

Once the MCP server is connected, Claude has 45 tools available. Here's what that looks like in a real conversation:

User: "Check my wallet balance"
→ Claude calls get_balance tool → returns balance

User: "Swap 0.1 SOL for USDC on Jupiter"
→ Claude calls execute_action tool with jupiter-swap provider

User: "Show my DeFi positions across all protocols"
→ Claude calls get_defi_positions tool → returns lending/staking positions
Enter fullscreen mode Exit fullscreen mode

The 45 tools span five categories: wallet operations (get-balance, get-address, get-assets, get-wallet-info), transactions (send-token, send-batch, sign-message, simulate-transaction), DeFi (get-defi-positions, get-health-factor, hyperliquid, polymarket, action-provider), NFTs (list-nfts, get-nft-metadata, transfer-nft), and infrastructure (x402-fetch, wc-connect, erc8004-get-reputation, list-sessions).

The DeFi coverage comes from 15 integrated protocol providers: aave-v3, across, dcent-swap, drift, erc8004, hyperliquid, jito-staking, jupiter-swap, kamino, lido-staking, lifi, pendle, polymarket, xrpl-dex, and zerox-swap. When Claude calls the action-provider tool, it can route to any of these.

Running Multiple Wallets with Separate Contexts

One pattern that works well is giving different Claude "agents" access to different wallets with different permission levels. A trading agent gets a wallet with DeFi policies enabled; a utility agent gets a wallet that can only send to whitelisted addresses. You configure this with multiple MCP server entries:

{
  "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-solana": {
      "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": "solana-wallet",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Each entry connects to the same daemon but authenticates as a different agent with a different wallet and its own policy set. The daemon handles the isolation — your keys never leave your machine.

Policies: What the Agent Is Allowed to Do

Handing an AI agent a wallet with no guardrails is a bad idea. WAIaaS has a policy engine with 21 policy types and a default-deny stance: if you haven't explicitly allowed a token or contract, transactions are blocked.

The most useful policy to start with is SPENDING_LIMIT, which maps transaction amounts to four security tiers:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 100,
      "notify_max_usd": 500,
      "delay_max_usd": 2000,
      "delay_seconds": 900,
      "daily_limit_usd": 5000
    }
  }'
Enter fullscreen mode Exit fullscreen mode

Under $100, the transaction executes immediately. Between $100 and $500, it executes but you get a notification. Between $500 and $2000, it queues for 15 minutes — you can cancel it. Above $2000, it requires your explicit approval via WalletConnect or Telegram before anything moves.

The four tiers are INSTANT, NOTIFY, DELAY, and APPROVAL. They apply to every transaction type, including DeFi actions. If Claude decides to open a $5000 perpetual position on Hyperliquid, that hits the APPROVAL tier and your phone gets a notification before anything executes.

You can also use simulate-transaction before committing:

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "TRANSFER",
    "to": "recipient-address",
    "amount": "0.1",
    "dryRun": true
  }'
Enter fullscreen mode Exit fullscreen mode

The dryRun: true flag runs the full transaction pipeline — validation, policy checks, simulation — without broadcasting. Claude can use the simulate-transaction MCP tool the same way.

The Minimal Quick Start

To recap the fastest path from zero to Claude-with-a-wallet:

Step 1: Start the daemon

docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/waiaas/waiaas:latest

docker exec waiaas cat /data/recovery.key
Enter fullscreen mode Exit fullscreen mode

Step 2: Create a wallet and session

# Use the master password from recovery.key
curl -X POST http://127.0.0.1:3100/v1/wallets \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: <from-recovery.key>" \
  -d '{"name": "claude-wallet", "chain": "solana", "environment": "mainnet"}'
Enter fullscreen mode Exit fullscreen mode

Step 3: Add MCP config to Claude Desktop, using your session token

Step 4: Set a spending limit policy (strongly recommended before funding the wallet)

Step 5: Fund the wallet address and ask Claude to check its balance

The whole sequence takes under ten minutes. The daemon handles key management, transaction signing, policy enforcement, and the 45 MCP tools that Claude sees on the other end.

What's Next

WAIaaS is open source and self-hosted — your keys, your server, your policies. The 15 DeFi protocol integrations, 18 supported networks, and 7-stage transaction pipeline are all running locally on your machine. Start with the GitHub repository to browse the source, or visit waiaas.ai for documentation and the full feature breakdown. The interactive API reference at http://127.0.0.1:3100/reference is also worth a look once the daemon is running — it documents all 39 API route modules with live request examples.

Top comments (0)