Fuse Network

Servidor MCP para Fuse Network: saldos, tokens, staking, dados DeFi, swaps e transações on-chain.

Documentação

Servidor MCP Fuse

Servidor Model Context Protocol para a blockchain Fuse. Permite que agentes de IA (Claude, Cursor, Gemini, ...) leiam dados on-chain da Fuse, enviem transações com abstração de conta, implantem contratos e operem APIs Fusebox por meio de uma interface de ferramenta padrão.

Duas formas de usar:

Hospedado em https://mcp.fuse.io/mcp — gratuito, somente leitura, configurado com as chaves de API da Fuse. Nenhuma configuração além de apontar seu agente para a URL.
Auto-hospedado via Docker ou node dist/index.js — necessário para qualquer ferramenta de escrita (você deve controlar a chave privada) e para limites de taxa mais altos.

Três back-ends, em camadas:

viem JSON-RPC — primitivas de cadeia que qualquer nó público pode servir, além de escritas EOA (enviar FUSE, transferências ERC-20, chamadas genéricas de contrato, implantação de contratos, assinatura EIP-191 / EIP-712).
Fusebox Web SDK — APIs de leitura com valor agregado (preços de tokens, staking, portfólio, histórico de UserOp) e escritas de conta inteligente ERC-4337 via UserOperations (opcionalmente sem gás via paymaster da Fuse).
APIs REST Fusebox — acesso direto aos endpoints de Notificação, Carteira Inteligente, Trade e Explorer.

Instalação rápida para agentes de IA (hospedado em mcp.fuse.io)

O endpoint hospedado fala o transporte HTTP Streamable em https://mcp.fuse.io/mcp. Todas as ferramentas de leitura estão habilitadas; as ferramentas de escrita não estão (elas precisam de uma chave privada no servidor — veja Auto-hospedagem para escritas abaixo).

Claude Code

claude mcp add fuse --transport http https://mcp.fuse.io/mcp

Para remover depois: claude mcp remove fuse.

Cursor

Configurações → MCP → Adicionar novo servidor, ou edite ~/.cursor/mcp.json:

{
  "mcpServers": {
    "fuse": {
      "url": "https://mcp.fuse.io/mcp"
    }
  }
}

Claude Desktop

O Claude Desktop atualmente inicia servidores MCP como subprocessos locais, então ele fala com o endpoint hospedado por meio da ponte mcp-remote. Edite ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "fuse": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.fuse.io/mcp"]
    }
  }
}

Reinicie o Claude Desktop.

Continue (VS Code / JetBrains)

~/.continue/config.yaml:

mcpServers:
  - name: fuse
    url: https://mcp.fuse.io/mcp

Cline / Roo Code

Adicione via barra lateral MCP → "Adicionar servidor remoto", URL https://mcp.fuse.io/mcp. Ou edite ~/.cline/mcp_settings.json:

{
  "mcpServers": {
    "fuse": { "url": "https://mcp.fuse.io/mcp", "transport": "streamable-http" }
  }
}

Zed

~/.config/zed/settings.json:

{
  "context_servers": {
    "fuse": { "command": { "path": "npx", "args": ["-y", "mcp-remote", "https://mcp.fuse.io/mcp"] } }
  }
}

Qualquer outra coisa (cliente HTTP Streamable genérico)

Endpoint: https://mcp.fuse.io/mcp Transporte: HTTP Streamable (POST + upgrade SSE opcional) Autenticação: nenhuma no endpoint hospedado (é somente leitura)

Auto-hospedagem para escritas

O endpoint hospedado opera deliberadamente sem FUSE_PRIVATE_KEY — as ferramentas de escrita se recusam a operar. Execute sua própria instância quando precisar assinar transações, implantar contratos ou enviar UserOps ERC-4337.

Docker

docker build -t fuse-mcp-server .
docker run --rm -p 3000:3000 \
  -e MCP_TRANSPORT=http \
  -e FUSEBOX_PUBLIC_API_KEY=pk_live_... \
  -e FUSE_PRIVATE_KEY=0x... \
  -e FUSE_USE_PAYMASTER=true \
  fuse-mcp-server

Aponte seu agente para http://127.0.0.1:3000/mcp. Mesmas configurações acima, trocando a URL.

docker-compose

Coloque segredos em um arquivo .env ao lado de docker-compose.yml:

FUSEBOX_PUBLIC_API_KEY=pk_live_...
FUSEBOX_SECRET_API_KEY=sk_live_...
FUSE_PRIVATE_KEY=0x...
FUSE_USE_PAYMASTER=true

Então:

docker compose up -d

Node diretamente (modo stdio para clientes de subprocesso locais)

npm install
npm run build
FUSE_PRIVATE_KEY=0x... node dist/index.js

Para Claude Desktop / qualquer cliente que inicie o servidor como subprocesso:

{
  "mcpServers": {
    "fuse": {
      "command": "node",
      "args": ["/absolute/path/to/fuse-mcp-server/dist/index.js"],
      "env": {
        "FUSEBOX_PUBLIC_API_KEY": "pk_live_...",
        "FUSE_PRIVATE_KEY": "0x...",
        "FUSE_USE_PAYMASTER": "true"
      }
    }
  }
}

Ferramentas (v0.2) — 50 no total

Leituras RPC — 8 (nenhuma chave de API necessária)

Ferramenta	Descrição
`fuse_get_balance`	Saldo nativo de FUSE ou ERC-20.
`fuse_get_transaction`	Buscar uma transação.
`fuse_get_receipt`	Buscar um recibo de transação.
`fuse_read_contract`	Chamar qualquer função view/pure (ABI buscada automaticamente).
`fuse_get_token_metadata`	name / symbol / decimals / totalSupply.
`fuse_get_gas_price`	Preço atual do gás + sugestões de taxa EIP-1559.
`fuse_resolve_ens`	Resolver um nome ENS (requer `ENS_RPC_URL`).
`fuse_get_account_abstraction_info`	Estado ERC-4337 para uma conta inteligente.

Leituras do SDK Fusebox — 10 (requer `FUSEBOX_PUBLIC_API_KEY`)

fuse_list_wallet_tokens, fuse_list_wallet_nfts, fuse_get_staking_options, fuse_get_staked_tokens, fuse_get_token_price, fuse_get_token_price_change, fuse_get_token_price_history, fuse_list_supported_tokens, fuse_get_trade_quote, fuse_get_user_operations.

APIs REST Fusebox — 14 (requer `FUSEBOX_PUBLIC_API_KEY`; Notificação também precisa de `FUSEBOX_SECRET_API_KEY`)

Notificação (8): fuse_notification_{create,get,list_project,update,delete}_webhook, fuse_notification_{add,remove,list}_addresses. Carteira Inteligente (2): fuse_smart_wallet_authenticate, fuse_smart_wallet_get_actions. Trade (3, não-SDK): fuse_trade_indicative_price, fuse_trade_liquidity_sources, fuse_trade_price_change_over_duration. Explorer (1 despachante genérico): fuse_explorer_query — cobre todos os 40+ endpoints estilo etherscan.

Escritas EOA — 7 (requer `FUSE_PRIVATE_KEY`)

Ferramenta	Descrição
`fuse_get_signer_address`	Mostrar qual EOA o servidor controla.
`fuse_send_native`	Transferir FUSE nativo.
`fuse_send_erc20`	Transferir um ERC-20 (decimais detectados automaticamente).
`fuse_write_contract`	Chamada que altera estado (simula primeiro para revelar motivos de revert).
`fuse_deploy_contract`	Implantar a partir de bytecode + ABI + argumentos. Opcionalmente aguarda o recibo.
`fuse_sign_message`	Assinatura EIP-191 (`personal_sign`). Sem transmissão de tx.
`fuse_sign_typed_data`	Assinatura de dados estruturados EIP-712. Sem transmissão de tx.

Escritas de conta inteligente (UserOps ERC-4337) — 11 (requer `FUSE_PRIVATE_KEY` + `FUSEBOX_PUBLIC_API_KEY`)

fuse_smart_get_info, fuse_smart_transfer_{token,nft}, fuse_smart_approve_{token,nft}, fuse_smart_approve_and_call, fuse_smart_call_contract, fuse_smart_execute_batch, fuse_smart_swap_tokens, fuse_smart_stake_token, fuse_smart_unstake_token. Defina FUSE_USE_PAYMASTER=true para rotear pelo paymaster da Fuse (sem gás).

Configuração

Variável	Padrão	Propósito
`MCP_TRANSPORT`	`stdio`	`stdio` (subprocesso local) ou `http` (HTTP Streamable para hospedado/Docker).
`MCP_HTTP_HOST`	`0.0.0.0`	Host de bind HTTP.
`MCP_HTTP_PORT`	`3000`	Porta de escuta HTTP.
`MCP_HTTP_PATH`	`/mcp`	Caminho da rota HTTP.
`FUSE_NETWORK`	`mainnet`	`mainnet` (cadeia 122) ou `spark` (testnet, cadeia 123).
`FUSE_RPC_URL`	padrão da rede	Substituir o endpoint JSON-RPC.
`FUSE_EXPLORER_URL`	padrão da rede	Substituir a URL base do explorador Blockscout.
`FUSE_ENTRYPOINT_ADDRESS`	ERC-4337 v0.7 canônico	Substituir o EntryPoint.
`ENS_RPC_URL`	não definido	RPC da mainnet Ethereum para resolução de `.eth`.
`FUSEBOX_PUBLIC_API_KEY`	não definido	Chave de API pública — necessária para ferramentas SDK + REST + conta inteligente.
`FUSEBOX_SECRET_API_KEY`	não definido	Chave de API secreta (cabeçalho `API-SECRET`). Necessária apenas pelas ferramentas da API de Notificação.
`FUSEBOX_BASE_URL`	padrão do SDK	Substituir o host da API Fusebox do SDK.
`FUSEBOX_API_ORIGIN`	`https://api.fuse.io`	Substituir a origem da API Fusebox do cliente HTTP bruto.
`FUSE_PRIVATE_KEY`	não definido	Chave privada hex de 32 bytes para o assinante. Necessária por toda ferramenta de escrita. Lida uma vez na inicialização; nunca aceita como argumento de ferramenta.
`FUSE_USE_PAYMASTER`	`false`	Quando `true`, UserOps de conta inteligente roteiam pelo paymaster da Fuse (sem gás).

Modelo de segurança

Manuseio de chaves. Chaves privadas vivem apenas no ambiente do servidor. Elas nunca são aceitas como argumentos de ferramenta — isso as vazaria na transcrição da conversa do agente. O servidor lê FUSE_PRIVATE_KEY uma vez na inicialização e assina localmente.
Endpoint hospedado. https://mcp.fuse.io/mcp não tem FUSE_PRIVATE_KEY configurado. Ferramentas de escrita retornam um erro acionável apontando os usuários para auto-hospedagem. A chave pública Fusebox incluída lá é limitada por taxa para compartilhamento justo.
Produção auto-hospedada. Trate o servidor como um assinante de carteira quente. Execute-o próximo à sua aplicação, restrinja o ingresso, financie a EOA com o mínimo de FUSE que você está disposto a perder em um incidente de injeção de prompt e prefira o paymaster (FUSE_USE_PAYMASTER=true) para que a carteira inteligente possa transacionar sem manter gás.

Estrutura do projeto

.
├── Dockerfile                    Multi-stage build → distroless-ish Alpine runtime, non-root user
├── docker-compose.yml            One-line local deploy
├── .dockerignore
├── package.json
├── tsconfig.json
└── src/
    ├── index.ts                  Transport dispatcher (stdio | http)
    ├── server.ts                 Builds the McpServer + ToolContext
    ├── config.ts                 Env loading
    ├── types.ts                  Shared tool types
    ├── transports/
    │   ├── stdio.ts              Local subprocess transport
    │   └── http.ts               Streamable HTTP transport + /healthz
    ├── clients/
    │   ├── rpc.ts                viem PublicClient factories
    │   ├── signer.ts             EOA signer (viem WalletClient + ethers v5 Wallet)
    │   ├── explorer.ts           Blockscout ABI fetcher
    │   ├── fusebox.ts            Fusebox SDK factories (read-only + credentialed)
    │   └── fuseboxApi.ts         Raw HTTP client for Fusebox REST APIs
    ├── lib/
    │   ├── address.ts            Address validation, ENS heuristics, hex bytes
    │   ├── erc20.ts              ERC-20 ABI (read + write)
    │   ├── units.ts              parseAmount / fetchErc20Decimals
    │   ├── format.ts             BigInt-safe JSON serialization
    │   └── userOp.ts             UserOp response → JSON-safe summary
    └── tools/
        ├── index.ts              Registry (50 tools)
        ├── *.ts                  RPC reads (8)
        ├── listWalletTokens.ts … getUserOperations.ts   Fusebox SDK reads (10)
        ├── notifications/        Fusebox Notification API (8)
        ├── smartWallets/         Fusebox Smart Wallet API (2)
        ├── tradeApi/             Fusebox Trade API non-SDK endpoints (3)
        ├── explorerApi/          Fusebox Explorer API dispatcher (1)
        ├── writes/               EOA writes (7)
        └── smart/                Smart-account writes (11)