Skip to main content
Glama

WalletChan MCP

Connect AI agents to WalletChan accounts with popup approval by default, plus scoped delegated execution when you opt in. Works with Claude, Cursor, Codex, and other local MCP clients.

WalletChan MCP is a local Model Context Protocol server that lets an AI assistant prepare wallet actions, route normal requests to a paired wallet for approval, and execute pre-authorized agent flows through signed ERC-7710 delegations. It is designed for the same kind of chat-based onchain workflow as Base MCP, but the normal approval path happens through WalletChan RPC with WalletConnect or MetaMask Connect instead of Base Account.

For the normal walletconnect execution profile, nothing moves onchain just because the assistant suggests it: transactions and signatures still require you to review and approve them in the WalletChan popup. For delegated agent profiles, you approve a scoped ERC-7710 delegation once, then the local agent can execute only in-scope transactions through that delegation.

What You Can Do

  • Connect your WalletChan extension to an AI assistant via WalletConnect, or connect MetaMask Mobile through MetaMask Connect.

  • Check connected wallets and portfolio balances.

  • Resolve user-provided names to EVM addresses with WalletChan extension parity: ENS/subdomains, Basenames, WNS .wei, GNS .gwei, and MegaNames .mega.

  • Swap and bridge tokens using WalletChan's first-party APIs.

  • Send transactions, ERC-5792 batch calls, sequential fallback call sets, and sign messages.

  • Create local encrypted agent wallets and choose an execution profile for future delegated/relayed execution while keeping the main-wallet approval path available.

  • Delegate scoped permissions from your main WalletChan wallet to 1Shot so an agent can relay in-scope DeFi transactions without a WalletChan popup every time.

  • Use one-time WalletChan signature approvals for reusable function-call delegations, so matching contract calls can be consumed later by the agent until the signed scope no longer covers the request.

  • Use Base MCP-style DeFi skills when a protocol skill can produce wallet calls for WalletChan approval or delegated agent execution.

  • Use Veil Cash on Base through a managed Veil MCP child process, with register/deposit calldata approved by WalletChan.

Skill

What It Supports

Morpho

Vault discovery and prepared supply/deposit flows.

Moonwell

Lending market discovery and prepared supply/borrow flows.

Aerodrome

Pool discovery, swap/liquidity preparation through supported CLI flows.

Uniswap

Pool and liquidity workflows when the skill returns executable calls.

Avantis

Perps market actions when the skill returns executable calls.

Bankr

Token discovery and supported token actions.

Virtuals

Agent/token discovery and SIWE login with WalletChan signature approval.

Veil

Local key setup, status/balances, register/deposit preparation, and WalletChan-approved public deposits.

Related MCP server: Coinbase AgentKit MCP Server

Requirements

  • Node.js 20.19.0 or newer.

  • WalletChan browser extension or any other wallet supporting WalletConnect, or MetaMask Mobile for MetaMask Connect.

  • An MCP client that supports local stdio MCP servers, such as Claude Desktop, Claude Code, Cursor, or Codex.

WalletChan MCP starts a local walletchan-rpc bridge for you. You do not need to run a separate RPC process in normal use.

Install

Add WalletChan MCP to your MCP client with npx:

{
  "mcpServers": {
    "walletchan": {
      "command": "npx",
      "args": ["-y", "@walletchan/mcp"]
    }
  }
}

Restart or reload your MCP client after changing its config.

Claude Desktop

Open Claude Desktop settings, find the developer/MCP configuration file, and add:

{
  "mcpServers": {
    "walletchan": {
      "command": "npx",
      "args": ["-y", "@walletchan/mcp"]
    }
  }
}

Restart Claude Desktop. In a new chat, ask:

Connect to WalletChan.

Claude Code

Install globally:

claude mcp add --scope user walletchan -- npx -y @walletchan/mcp

Verify:

claude mcp list

Inside a Claude Code session, /mcp should show walletchan as active.

Cursor

Add this to ~/.cursor/mcp.json for global use, or .cursor/mcp.json for one project:

{
  "mcpServers": {
    "walletchan": {
      "command": "npx",
      "args": ["-y", "@walletchan/mcp"]
    }
  }
}

Restart Cursor, then open Cursor settings and confirm the WalletChan MCP server is active.

Codex

Add the local stdio server:

codex mcp add walletchan -- npx -y @walletchan/mcp

Or add it manually to your Codex MCP config:

[mcp_servers.walletchan]
command = "npx"
args = ["-y", "@walletchan/mcp"]

ChatGPT

ChatGPT custom connectors currently expect remote HTTPS MCP servers. WalletChan MCP is intentionally local because it talks to your local WalletChan extension. Use it with local MCP clients such as Claude Desktop, Claude Code, Cursor, or Codex unless you intentionally run your own private MCP relay.

First Connection

After installation, ask your assistant:

Connect to WalletChan.

The assistant should call get_pairing_uri and show the pairing result. The response includes a local pairingUrl such as http://127.0.0.1:4209/qr; open it to scan a browser QR code or copy the raw pairing URI. Clients that render MCP images may also show a QR code directly in chat. WalletConnect URIs start with wc:. MetaMask Connect URIs may use a MetaMask deep link or app link.

For WalletConnect with WalletChan:

  1. Open the extension.

  2. Go to More -> WalletConnect.

  3. Scan the browser QR, scan the chat QR if your client displayed one, or paste the URI.

  4. Approve the pairing.

After pairing, ask:

Show me my connected WalletChan wallets.

To switch wallets or force a fresh proposal, ask the assistant to get a new WalletChan pairing URI. The tool supports forceNewSession: true; this clears the selected transport session and returns a new QR/URI. The browser QR page also has a fresh URI control, or can be opened with /qr?force=true.

To switch the already-running managed RPC to MetaMask Connect without restarting MCP:

get_pairing_uri({ walletTransport: "metamask-connect", forceNewSession: true })

To switch back to WalletConnect:

get_pairing_uri({ walletTransport: "walletconnect", forceNewSession: true })

For MetaMask Connect account changes, call get_wallets after switching accounts in MetaMask Mobile. If the address still has not updated, ask MetaMask Connect to request the account explicitly:

get_pairing_uri({ walletTransport: "metamask-connect", account: "0x...", forceRequest: true })

The assistant should report the approved wallet address and chain.

Name Resolution

WalletChan MCP exposes forward name resolution tools for user-provided recipient or signer inputs:

resolve_name({ name: "vitalik.eth" })
resolve_name({ name: "name.base.eth" })
resolve_name({ name: "name.wei" })
resolve_name({ name: "name.gwei" })
resolve_name({ name: "name.mega" })

resolve_names resolves a batch. The tools support the same forward-resolution families as the extension: ENS and subdomains, Basenames under .base.eth, WNS .wei, GNS .gwei, and MegaNames .mega. They use MCP --rpc overrides first for the relevant chain, then WalletChan default RPCs. They do not reverse-resolve addresses, fetch avatars, or silently rewrite transaction inputs; agents should call resolve_name explicitly, show the resolved address when useful, then pass the returned address into wallet tools.

Try It

Once connected, try prompts like:

What's my USDC balance on Base?
Swap 5 USDC to ETH on Base with WalletChan.
Bridge 0.01 ETH from Base to Ethereum with WalletChan.
Find USDC vault options on Morpho Base, then prepare a 1 USDC deposit into the vault I choose.
Sign in to Virtuals with my WalletChan wallet.

For transactions and signatures, the assistant prepares the request and WalletChan opens a popup when the execution profile is walletconnect. Agent profiles use a local agent key plus signed delegations, so in-scope transactions do not open a popup each time.

Agent Wallets, Delegations, and 1Shot

WalletChan MCP supports three execution profiles:

Profile

What happens

walletconnect

Uses the paired WalletChan wallet and opens WalletChan popup approval for transactions/signatures.

agent:<walletId>

Uses a local encrypted agent wallet plus signed ERC-7710 delegations from the main wallet, then submits matching calls through the 1Shot relayer.

agent-eoa:<walletId>

Signs directly with the raw local agent EOA and broadcasts sequential calls. This bypasses WalletChan popup approval and is only for explicit raw-agent use.

The delegated agent flow does not fund the local agent EOA for normal DeFi actions. The main WalletChan wallet remains the delegator/source account. The agent wallet signs and submits the redelegated permission context, while 1Shot relays the transaction. That is why an unfunded agent EOA can still execute a delegated Morpho deposit from the main wallet when the signed delegation covers the prepared calls.

Create or import an agent wallet:

agent_create_wallet({ label: "Hackathon Agent" })

or:

agent_import_wallet({ privateKey: "0x...", label: "Hackathon Agent" })

No env setup is required for the normal path. MCP creates a local vault-secret file automatically on first use; private keys and signed delegation payloads are encrypted locally and never returned by tools.

Inspect and choose execution profiles:

list_execution_profiles()
set_default_execution_profile({ profileId: "agent:<walletId>" })
get_default_execution_profile()
clear_default_execution_profile()

Setting the default to agent:<walletId> makes mutating tools try delegated 1Shot execution by default. Use a per-call executionProfile: "walletconnect" override when the user wants the normal WalletChan popup path for a specific transaction. Use agent-eoa:<walletId> only when the user explicitly wants the raw local agent wallet to spend directly.

For 1Shot delegated DeFi execution, the delegation target must be the 1Shot relayer targetAddress. agent_prepare_delegation defaults to delegateMode: "oneshot-relayer" and resolves the current target automatically:

agent_prepare_delegation({
  walletId: "<walletId>",
  chain: 8453,
  amount: "10",
  label: "Base agent allowance"
})
agent_request_delegation_signature({ delegationId: "<delegationId>" })

After the WalletChan popup is approved:

agent_complete_delegation({ delegationId: "<delegationId>" })
set_default_execution_profile({ profileId: "agent:<walletId>" })

That first delegation can cover direct token-transfer-style actions, depending on its scope. DeFi protocols usually need more than a token transfer. For example, a Morpho USDC vault deposit may require a USDC approval call and a vault deposit call, so a simple daily USDC transfer scope is not enough.

When a prepared DeFi transaction needs protocol contract calls outside the active delegation, MCP preflights the call bundle and returns a structured request such as needs_function_call_delegation / needs_delegation_signature. The response includes prepareDelegationArgs and often recommendedNextArgs. The assistant should use those arguments exactly:

agent_prepare_delegation({ ...prepareDelegationArgs })
agent_request_delegation_signature({ delegationId: "<delegationId>" })

After the user approves the one-time WalletChan signature request:

agent_complete_delegation({ ...recommendedNextArgs })

This stores a reusable function-call delegation scoped to the prepared targets/selectors, such as USDC approve plus a Morpho vault deposit selector. Future matching calls can be consumed by the agent without new WalletChan popups until the signed scope, expiry, or configured limits no longer cover the request. If a future transaction targets a different contract or selector, MCP asks for a new scoped delegation instead of silently broadening authority.

Once the agent profile is active, these tools can route through the selected profile unless an executionProfile override is passed:

  • send_calls

  • send_prepared_calls

  • send_transaction

  • swap

  • bridge

  • run_base_plugin_cli({ submitPreparedCalls: true })

For Base DeFi skill flows, run_base_plugin_cli and send_prepared_calls treat the delegation delegator as the protocol user. Supported CLI write commands automatically bind owner-style arguments such as Morpho user-address and Aerodrome wallet to the main delegator address, not the local agent EOA. This prevents false insufficient-balance simulations against an unfunded agent wallet.

Confirmed 1Shot submissions always estimate before sending. When 1Shot returns a higher requiredPaymentAmount, MCP updates only the ERC-20 transfer to the 1Shot fee collector, adds a tiny fee buffer, and re-estimates, preserving protocol approvals/deposits in the bundle. If estimation still fails, MCP returns status: "estimate_failed" and does not submit a relayer task.

Use these 1Shot tools directly when debugging or building a custom flow:

  • agent_oneshot_get_capabilities

  • agent_oneshot_get_fee_data

  • agent_oneshot_relay_calls

  • agent_oneshot_get_status

For x402 hackathon resources, use agent_x402_quote and agent_x402_pay. The default agent:<walletId> path pays through the main wallet's ERC-7710 delegation only when the endpoint advertises extra.assetTransferMethod: "erc7710". x402 requires a separate delegation with delegateMode: "agent-wallet" because x402 delegated payment targets the local agent wallet address, not the 1Shot relayer target. Use agent-eoa:<walletId> only when the user explicitly wants raw agent-wallet USDC payment.

If agent_x402_quote returns delegatedPaymentSupported: false, the endpoint cannot be paid through the delegated agent path directly. Do not retry with agent-eoa unless you explicitly want to spend the agent wallet's own USDC. For future demos, prefer a WalletChan-owned x402 endpoint that advertises ERC-7710 delegated payment directly.

How Base MCP-Style Skills Work

WalletChan MCP includes skill resources and tool adapters for Base MCP-style plugin workflows.

When a Base skill says to use Base MCP wallet tools such as send_calls, sign, or an approval URL, the assistant should use WalletChan MCP tools instead:

  • Base send_calls -> WalletChan send_calls

  • Prepared protocol transaction response -> WalletChan send_prepared_calls

  • Base sign -> WalletChan sign or sign_siwe

  • Base approval link -> WalletChan popup approval

Some protocol skills fetch data from protocol APIs, run protocol CLIs, or call protocol MCP servers. WalletChan MCP provides narrow, allowlisted helpers for common cases:

  • web_request for allowlisted HTTPS protocol APIs.

  • run_base_plugin_cli for pinned protocol CLIs such as Morpho and Aerodrome.

  • list_remote_mcp_tools and call_remote_mcp_tool for allowlisted remote protocol MCP profiles.

  • start_remote_mcp_siwe_login and complete_remote_mcp_siwe_login for SIWE login flows that must preserve the exact challenge message.

  • list_protocols, list_protocol_tools, and call_protocol_tool for managed protocol integrations such as Veil MCP.

WalletChan MCP does not run arbitrary shell commands, proxy arbitrary MCP servers, or call arbitrary web hosts from a skill file.

Veil Cash

WalletChan MCP can start a managed Veil MCP child process for Veil Cash on Base. Public Veil actions use Veil MCP to prepare calldata, then WalletChan MCP submits that calldata through the existing WalletChan popup approval path.

Useful prompts:

Check my Veil status.
Register my WalletChan account with Veil.
Prepare a 20 USDC Veil deposit and submit it through WalletChan.

Veil key material is managed by Veil MCP locally, not by the WalletChan extension vault. WalletChan MCP launches Veil MCP in a controlled working directory so .env.veil and .veil-x402-receipts.json are not written into your project or random MCP client launch directories. Override the directory with WALLETCHAN_MCP_VEIL_DIR. WalletChan MCP also passes a Base RPC_URL to Veil; it is inherited from the global WalletChan MCP Base RPC override (--rpc base=<url> or WALLETCHAN_MCP_RPC_OVERRIDES=base=<url>) or defaults to https://base.drpc.org.

Veil x402 payment submits through the Veil relay and does not open a WalletChan popup. Use veil_x402_quote first, then call veil_pay_x402 with a tight maxPayment and confirm: true after the user approves the exact spend. WalletChan MCP blocks under-minimum relay attempts before calling Veil: normal withdrawals require at least 0.001 ETH or 0.01 USDC, and x402 payments require a supported quote of at least 0.01 USDC. Other private Veil relay tools such as withdraw, transfer, and UTXO consolidation remain disabled by default; enable them only for explicit user-controlled flows with WALLETCHAN_MCP_VEIL_PRIVATE_ACTIONS=true.

If the hosted Veil relay returns Gas price too high, try again later, WalletChan MCP surfaces a dedicated error explaining that the relay refused the private withdrawal because Base gas is above the relay cap. WalletChan MCP cannot override that cap with --rpc base=...; x402 callers should check for an already-funded payer once, then wait before retrying if none can cover the payment.

Advanced Configuration

By default WalletChan MCP:

  • starts a managed walletchan-rpc child process;

  • listens on http://127.0.0.1:4209;

  • uses Base as the default chain;

  • uses WalletChan's first-party API at https://walletchan.com/api.

Use an existing RPC bridge instead of the managed child process:

walletchan-mcp --no-managed-rpc --rpc-url http://127.0.0.1:4209

Expose more chains to WalletChan RPC:

walletchan-mcp --chain base --chain ethereum --chain polygon

Start the managed RPC with MetaMask Connect instead of WalletConnect:

walletchan-mcp --wallet-transport metamask-connect

The same default can be set with WALLETCHAN_MCP_WALLET_TRANSPORT=metamask-connect.

Use a different local RPC port:

walletchan-mcp --rpc-url http://127.0.0.1:4210

Bind the managed RPC to all interfaces inside an isolated container while Docker publishes the port only to host loopback:

walletchan-mcp --rpc-host 0.0.0.0

Disable protocol helper surfaces:

walletchan-mcp --disable-plugin-cli --disable-web-request

Disable the managed Veil MCP integration:

walletchan-mcp --disable-veil

Use a persistent global Veil MCP binary for faster startup:

npm install -g @veil-cash/mcp@0.2.1
walletchan-mcp --veil-command veil-mcp

Use a dedicated Veil data directory:

walletchan-mcp --veil-dir ~/.walletchan-mcp/veil

Use a dedicated Base RPC for both WalletChan RPC and Veil:

walletchan-mcp --rpc base=https://your-base-rpc.example

Use dedicated RPCs for name resolution:

walletchan-mcp --chain ethereum --rpc ethereum=https://your-ethereum-rpc.example
walletchan-mcp --chain megaeth --rpc megaeth=https://your-megaeth-rpc.example

Ethereum RPC is used for ENS, Basenames, .wei, and .gwei. MegaETH RPC is used for .mega.

Add an extra allowlisted HTTPS host for protocol data:

walletchan-mcp --allow-web-host api.example.org

Agent Wallet Storage and Recovery

WalletChan MCP can create or import local agent wallets for delegated agent execution work. Agent wallet metadata, private keys, and signed delegation payloads are stored encrypted locally.

No env setup is required for the normal path. On first agent wallet create/import, MCP generates a random vault-secret file under the agent-wallet data directory, locks it down with best-effort 0600 permissions, and uses it to encrypt the local key vault. WALLETCHAN_MCP_AGENT_VAULT_SECRET and WALLETCHAN_MCP_AGENT_VAULT_SECRET_FILE remain advanced overrides for migration/recovery.

Agent wallets are stored under the WalletChan MCP app-data root in an agent-wallets directory by default. Override the exact directory with WALLETCHAN_MCP_AGENT_WALLET_DIR.

To intentionally forget all local agent wallets/delegations and start fresh, call:

agent_reset_vault({ confirm: true, confirmationText: "RESET_AGENT_VAULT" })

This does not require the old vault secret. The next agent_create_wallet or agent_import_wallet call creates a new local vault-secret file automatically.

If an old agent-wallets.json exists but the matching vault secret is unavailable, MCP may still list the public wallet metadata. Those agent profiles are marked locked, and the effective default falls back to walletconnect until you restore the old secret or run agent_reset_vault.

Raw agent EOA helpers:

Show the Base USDC balance for my raw agent wallet.
Use the raw agent wallet to send this prepared transaction.

The raw agent-eoa path signs locally and broadcasts directly to the configured chain RPC. It does not open a WalletChan popup, and sequential raw calls are not atomic. Use the walletconnect profile whenever the user wants their main WalletChan wallet approval flow.

Security Model

  • WalletChan MCP never receives your main WalletChan private keys or seed phrase. Local agent wallet keys are created or imported into MCP only when you use agent-wallet tools.

  • The walletconnect profile does not approve transactions by itself. Transaction and signature approval happens in the WalletChan extension.

  • The delegated agent profile can execute without a per-transaction popup only after the main WalletChan wallet signs an ERC-7710 delegation. Execution remains bounded by the signed delegation scope, target, selectors, expiry, and configured limits.

  • Signed delegation payloads are stored encrypted because they authorize future in-scope execution.

  • Local agent wallet private keys are encrypted on disk with AES-256-GCM and PBKDF2-SHA256 using the local vault-secret file or an advanced env override; no MCP tool returns private keys.

  • Raw agent-eoa tools sign locally and broadcast directly from the agent wallet. They must only be used when the user explicitly chooses the raw agent wallet.

  • Protocol helpers are allowlisted and constrained.

  • CLI helpers use pinned packages, structured arguments, no shell execution, timeouts, and output caps.

  • web_request only supports allowlisted HTTPS hosts.

  • send_prepared_calls refuses protocol prepare responses with error-level warnings unless the user explicitly chooses to continue.

  • Managed protocol integrations run in controlled working directories. Veil .env.veil stays in the managed Veil directory unless you override it.

  • Veil x402 relay payment requires a quoted cap and explicit confirmation; broader Veil private relay actions are disabled by default because they do not use WalletChan popup approval.

The normal wallet-transport approval path is:

AI assistant -> WalletChan MCP -> local walletchan-rpc -> WalletConnect or MetaMask Connect -> wallet approval UI -> user approval

The delegated agent execution path is:

AI assistant -> WalletChan MCP agent profile -> signed ERC-7710 delegation -> 1Shot relayer -> in-scope onchain execution

Troubleshooting

The assistant cannot find WalletChan tools

Restart or reload your MCP client after adding the config. In Claude Code, run /mcp. In Cursor, check Settings -> MCP.

The assistant shows a pairing URI but pairing does not complete

Make sure your wallet is unlocked, open the returned pairingUrl or paste the full raw URI, and approve the pairing in the wallet. If the URI expired, ask the assistant to connect again.

The assistant does not show a QR code

WalletChan MCP returns a standard MCP image block for WalletConnect and MetaMask Connect pairing URIs, but terminal clients may show only text or an image placeholder. Use the raw URI in the same response as the fallback.

For a scannable QR that does not depend on chat image rendering, open the pairingUrl returned by get_pairing_uri, usually http://127.0.0.1:4209/qr.

A transaction tool says needs_pairing

The selected wallet transport session was closed or expired. Pair again with the URI returned by the tool. For prepared DeFi transactions, ask the assistant to prepare a fresh transaction before resubmitting.

An old agent wallet still appears

Agent wallet public metadata is stored in agent-wallets.json, so it may still be listed after removing an old vault secret. If the matching secret is unavailable, the profile is marked locked and does not remain the effective default. To intentionally forget local agent wallets/delegations and start fresh, call:

agent_reset_vault({ confirm: true, confirmationText: "RESET_AGENT_VAULT" })

A protocol skill cannot fetch data

Some DeFi skills depend on external protocol APIs, protocol CLIs, or remote MCP servers. WalletChan MCP includes allowlisted helpers for common Base skill patterns, but it intentionally does not provide arbitrary network or shell access. If a future skill needs a new host, CLI runner, or MCP profile, it should be added explicitly.

Local Development

From this repository:

pnpm install --frozen-lockfile
pnpm build

Use the built local server:

{
  "mcpServers": {
    "walletchan": {
      "command": "node",
      "args": ["/path/to/walletchan-mcp/dist/index.js"]
    }
  }
}

For local iteration:

pnpm dev

Maintainer documentation

See _docs/IMPLEMENTATION.md for architecture and release checks.

Available Tools

65 tools
agent_complete_delegationComplete Agent DelegationA

Complete a pending agent delegation after the WalletChan signature request is approved, verify the signer, and store the signed delegation encrypted in the agent vault.

Inputs: delegationId (required), requestId, signature, pendingActionId, +1 more.

agent_create_walletCreate Agent WalletB

Create a local encrypted agent wallet. Creates a local vault-secret file automatically when needed. Returns address and profile IDs, never the private key.

Inputs: label.

agent_delete_delegationDelete Agent DelegationA

Delete a locally stored agent delegation session. This does not revoke onchain permissions; it only removes MCP's local artifact. Requires confirm=true.

Inputs: confirm (required), delegationId (required).

agent_delete_walletDelete Agent WalletA

Delete a local encrypted agent wallet and its private key material. Requires confirm=true.

Inputs: confirm (required), walletId (required).

agent_eoa_get_balanceGet Agent EOA BalanceA

Read native or ERC-20 balance for a raw local agent EOA profile. Does not require WalletConnect pairing.

Inputs: chain, token, walletId, profileId.

agent_eoa_send_callsSend Agent EOA CallsA

Sign and broadcast calls sequentially from a raw local agent EOA. This path is not atomic and bypasses WalletChan popup approval.

Inputs: calls (required), chain, walletId, profileId.

agent_eoa_send_transactionSend Agent EOA TransactionA

Sign and broadcast a transaction directly from a raw local agent EOA. This bypasses WalletChan popup approval and should be used only when the user explicitly chose the raw agent wallet.

Inputs: to, gas, data, chain, +6 more.

agent_get_delegationGet Agent DelegationA

Get one local agent delegation. By default returns metadata only; pass includePayload=true to include encrypted-vault payload after decrypting locally.

Inputs: delegationId (required), includePayload.

agent_get_walletGet Agent WalletA

Get one local agent wallet metadata record and its profile IDs. Does not decrypt or return the private key.

Inputs: walletId (required).

agent_import_walletImport Agent WalletA

Import a local encrypted agent wallet private key. Creates a local vault-secret file automatically when needed. Returns address and profile IDs, never the private key.

Inputs: privateKey (required), label.

agent_list_delegationsList Agent DelegationsB

List local agent delegation metadata. Signed delegation payloads remain encrypted and are not returned.

Inputs: status, chainId, walletId.

agent_list_walletsList Agent WalletsA

List local agent wallet metadata and profile IDs. Does not decrypt or return private keys.

Inputs: no named parameters.

agent_oneshot_get_capabilitiesGet 1Shot CapabilitiesC

Fetch 1Shot public relayer capabilities for one or more chains. agent_prepare_delegation resolves targetAddress automatically when delegateMode is oneshot-relayer.

Inputs: chainIds.

agent_oneshot_get_fee_dataGet 1Shot Fee DataC

Fetch 1Shot public relayer fee data for a chain/payment token pair.

Inputs: token, chainId.

agent_oneshot_get_statusGet 1Shot StatusB

Poll 1Shot public relayer status for a submitted task ID.

Inputs: taskId (required), logs.

agent_oneshot_relay_callsRelay Agent Calls With 1ShotA

Build, estimate, or submit an ERC-7710 delegated transaction bundle through the 1Shot public relayer. Requires an active 1Shot-compatible agent delegation whose delegate equals the relayer targetAddress. Uses preview mode unless confirm=true.

Inputs: calls (required), memo, chain, submit, +13 more.

agent_prepare_delegationPrepare Agent DelegationA

Create a pending ERC-7710 delegation from the connected WalletChan wallet. Defaults to a 1Shot-compatible relayer delegation with a Base USDC daily spend scope. Stores the unsigned delegation payload encrypted in the agent vault.

Inputs: chain, label, amount, walletId, +16 more.

agent_request_delegation_signatureRequest Agent Delegation SignatureA

Open a WalletChan eth_signTypedData_v4 request for a pending agent delegation. The user approves with the main WalletChan wallet in the popup.

Inputs: delegationId (required).

agent_reset_vaultReset Agent VaultA

Forget all local agent wallets, delegations, and default agent profile without decrypting the vault. Use this when you intentionally want a fresh agent-wallet setup, especially after removing an old env vault secret. Requires confirm=true and confirmationText=RESET_AGENT_VAULT.

Inputs: confirm (required), confirmationText (required).

agent_x402_payPay x402 Resource With AgentB

Pay and fetch an x402-protected HTTPS resource. The default agent profile spends through the main wallet's ERC-7710 delegation; explicitly pass agent-eoa: only for raw agent-wallet payment.

Inputs: url (required), body, chain, method, +8 more.

agent_x402_quoteQuote x402 ResourceA

Probe an x402-protected HTTPS resource without signing or submitting payment. Reports whether the endpoint offers ERC-7710 delegated x402 payment for agent profiles.

Inputs: url (required), body, chain, method, +6 more.

bridgeBridgeB

Quote a WalletChan bridge, build needed approval plus bridge calls, and submit them to WalletChan for popup approval unless previewOnly is true.

Inputs: inputToken (required), outputToken (required), from, chain, +16 more.

call_protocol_toolCall Protocol ToolA

Call a raw allowlisted protocol tool. Prefer first-class WalletChan wrappers when available.

Inputs: tool (required), protocol (required), arguments, timeoutMs.

call_remote_mcp_toolCall Remote MCP ToolB

Call an allowlisted protocol MCP tool through WalletChan MCP. Login tools are blocked here; use the remote SIWE login helpers.

Inputs: tool (required), profile (required), arguments.

clear_default_execution_profileClear Default Execution ProfileA

Clear the stored default execution profile. Future mutating tools fall back to walletconnect.

Inputs: no named parameters.

complete_remote_mcp_siwe_loginComplete Remote MCP SIWE LoginB

Complete a remote MCP SIWE login after the WalletChan signature request has been approved.

Inputs: loginId (required).

get_bridge_quoteGet Bridge QuoteC

Fetch a WalletChan bridge quote using the same first-party Bungee proxy as the extension.

Inputs: inputToken (required), outputToken (required), from, chain, +11 more.

get_bridge_statusGet Bridge StatusB

Fetch WalletChan bridge status by Bungee requestHash or source txHash.

Inputs: txHash, requestHash.

get_default_execution_profileGet Default Execution ProfileA

Get the stored default execution profile. Defaults to walletconnect when no explicit default is stored.

Inputs: no named parameters.

get_pairing_uriGet Pairing URIA

Start or inspect the managed WalletChan RPC bridge and return the wallet pairing URI and local QR page URL when pairing is needed. The URI may be WalletConnect or MetaMask Connect depending on the managed RPC transport. When a pairing URI is available, the tool emits an MCP image content block with the QR code before the text fallback.

Inputs: force, waitMs, account, transport, +3 more.

get_portfolio_balancesGet Portfolio BalancesB

Fetch WalletChan portfolio balances for an address or the connected WalletChan account, including tokens and DeFi positions.

Inputs: from, limit, address, includeDefi, +1 more.

get_request_statusGet Request StatusC

Get the status of a WalletChan MCP request or wallet_sendCalls bundle.

Inputs: id, requestId.

get_swap_priceGet Swap PriceB

Fetch an indicative WalletChan swap price using the same first-party swap API as the extension.

Inputs: buyToken (required), sellToken (required), from, chain, +7 more.

get_walletsGet WalletsC

Get approved WalletChan RPC accounts and configured chains.

Inputs: chain.

list_base_plugin_runnersList Base Plugin RunnersA

List pinned protocol CLI runners and supported commands available inside WalletChan MCP.

Inputs: no named parameters.

list_execution_profilesList Execution ProfilesB

List WalletChan execution profiles. walletconnect uses the existing WalletChan popup path; agent and agent-eoa profiles are local agent wallet profiles for delegated and raw execution.

Inputs: no named parameters.

list_protocolsList ProtocolsB

List protocol integrations managed by WalletChan MCP, including local MCPs, CLIs, HTTP APIs, or future SDK adapters.

Inputs: no named parameters.

list_protocol_toolsList Protocol ToolsC

List raw tools exposed by a managed protocol integration such as Veil MCP.

Inputs: protocol (required).

list_remote_mcp_toolsList Remote MCP ToolsB

List tools from an allowlisted protocol MCP profile. Currently supports the Virtuals ACP MCP profile.

Inputs: profile (required).

list_skill_resourcesList Skill ResourcesC

List WalletChan MCP skill and adapted Base plugin resources.

Inputs: no named parameters.

load_base_pluginLoad Base PluginC

Load an upstream Base MCP native plugin reference with WalletChan MCP execution overrides prepended.

Inputs: plugin (required).

resolve_nameResolve NameB

Resolve a user-provided WalletChan-supported name to an EVM address. Supports ENS and subdomains, Basenames under .base.eth, WNS .wei, GNS .gwei, and MegaNames .mega. Uses MCP RPC overrides first, then WalletChan default RPCs.

Inputs: name (required).

resolve_namesResolve NamesC

Resolve multiple user-provided WalletChan-supported names to EVM addresses. Supports ENS/subdomains, Basenames, .wei, .gwei, and .mega.

Inputs: names (required).

run_base_plugin_cliRun Base Plugin CLIB

Run a pinned, allowlisted protocol CLI command from the local WalletChan MCP process. Supports configured Base plugin CLI runners and can submit prepared transaction output through WalletChan.

Inputs: plugin (required), command (required), args, from, +8 more.

send_callsSend CallsB

Submit wallet calls through WalletChan RPC. Uses ERC-5792 wallet_sendCalls when the wallet supports it, otherwise sends the calls sequentially as individual user-approved transactions.

Inputs: calls (required), chain (required), from, profileId, +2 more.

send_prepared_callsSend Prepared CallsA

Normalize a Base plugin prepare response into wallet calls and submit it through WalletChan. Accepts common shapes like transactions[], calls[], {data:{to,value,data}}, and approval+action objects. Non-batching wallets get sequential transaction fallback.

Inputs: prepared (required), from, chain, profileId, +4 more.

send_transactionSend TransactionC

Start a single eth_sendTransaction request through WalletChan RPC for user approval.

Inputs: chain (required), to, data, from, +3 more.

set_default_execution_profileSet Default Execution ProfileA

Store the default execution profile for future mutating WalletChan MCP tools. Use walletconnect for the main WalletChan wallet, agent: for delegated agent execution, or agent-eoa: for raw local agent EOA execution.

Inputs: profileId (required).

signSignB

Start a WalletChan signature request. The user approves in the WalletChan popup.

Inputs: data, type, chain, address, +1 more.

sign_siweSign SIWEB

Validate an EIP-4361 SIWE message, then start a WalletChan personal_sign request for the exact message.

Inputs: uri, chain, nonce, domain, +11 more.

start_remote_mcp_siwe_loginStart Remote MCP SIWE LoginA

Start an allowlisted remote MCP SIWE login, preserve the exact challenge, and open a WalletChan signature request.

Inputs: profile (required), chain, address.

swapSwapB

Quote a WalletChan swap, build needed approval plus swap calls, and submit them to WalletChan for popup approval unless previewOnly is true.

Inputs: buyToken (required), sellToken (required), from, chain, +13 more.

veil_deposit_statusVeil Deposit StatusC

Check one queued Veil deposit by pool and nonce. Owner defaults to the first approved WalletChan account.

Inputs: pool (required), nonce (required), owner.

veil_get_balancesVeil BalancesB

Read public wallet balances, Veil queue balances, and private balances when the managed Veil key is available.

Inputs: pool, owner.

veil_init_keypairInitialize Veil KeypairB

Generate a random local Veil keypair in WalletChan MCP's managed Veil data directory. Returns the public deposit key but never returns VEIL_KEY.

Inputs: force.

veil_pay_x402Pay x402 ResourceA

Pay a Veil-supported x402 v2 exact Base USDC resource from private Veil USDC. Requires maxPayment and confirm=true after explicit user approval because this submits through the Veil relay without a WalletChan popup.

Inputs: url (required), confirm (required), maxPayment (required), body, +4 more.

veil_prepare_depositPrepare Veil DepositA

Prepare unsigned Base calldata for ETH or USDC Veil deposit. Set submitPreparedCalls=true to submit through WalletChan popup approval.

Inputs: asset (required), amount (required), from, chain, +5 more.

veil_prepare_registerPrepare Veil RegisterB

Prepare unsigned Base calldata to register or rotate the managed Veil deposit key. Set submitPreparedCalls=true to submit through WalletChan popup approval.

Inputs: from, chain, force, owner, +4 more.

veil_statusVeil StatusB

Check local Veil key status, relay health, and optional owner registration/wallet status on Base.

Inputs: owner.

veil_subaccount_statusVeil Subaccount StatusC

Read Veil subaccount status for a local Veil key slot.

Inputs: slot (required).

veil_wait_for_depositWait for Veil DepositB

Poll one queued Veil deposit until accepted, rejected, refunded, or timeout.

Inputs: pool (required), nonce (required), owner, timeoutSeconds, +1 more.

veil_x402_payer_balancesx402 Payer BalancesC

Inspect Base USDC balances held by deterministic x402 payer EOAs for the managed Veil key.

Inputs: count, discover, startIndex, nonZeroOnly.

veil_x402_quoteQuote x402 ResourceB

Probe an x402 resource without funding or paying from private Veil USDC.

Inputs: url (required), body, method, headers, +1 more.

veil_x402_receiptsx402 Spend HistoryC

List locally recorded Veil x402 payment receipts.

Inputs: limit.

web_requestWeb RequestB

Call an allowlisted HTTPS protocol API from the local WalletChan MCP process. Use this for Base plugin web_request paths when the host is allowed.

Inputs: url (required), body, method, headers, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.8/5.0

    Scored across 65 tools

    Disambiguation2/5

    Many tools have overlapping or layered purposes, e.g., send_transaction/send_calls/send_prepared_calls/agent_eoa_send_transaction/agent_eoa_send_calls, veil_deposit_status vs veil_wait_for_deposit, resolve_name vs resolve_names, and separate veil vs agent x402 quote/pay paths. Descriptions help, but an agent must still disambiguate between nearly identical wallet, agent, and Veil execution routes.

    Naming Consistency3/5

    Most names use snake_case, but the set mixes verb_noun (get_request_status), noun-only (swap, bridge, sign), and prefixed variants (veil_, agent_, list_, get_, send_). The conventions are readable but not predictable enough for a consistent naming score.

    Tool Count1/5

    65 tools is an extreme mismatch for a single MCP server, far beyond the typical 3-15 well-scoped range. The surface includes many overlapping variants and layers, making the set difficult to navigate rather than each tool clearly earning its place.

    Completeness3/5

    The surface covers a broad domain: wallet signing, transactions, swaps, bridges, agent wallets, delegations, Veil privacy, x402 payments, and protocol integrations. However, notable lifecycle gaps remain, such as onchain delegation revocation, transaction history/update/cancel operations, and explicit approval management.

    Maintenance

    ActivitySlowing
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers