Fuse Network

Servidor MCP para Fuse Network: saldos, tokens, staking, datos DeFi, swaps y transacciones en cadena.

Documentación

Servidor MCP de Fuse

Servidor del Model Context Protocol para la blockchain de Fuse. Permite a los agentes de IA (Claude, Cursor, Gemini, ...) leer datos on-chain de Fuse, enviar transacciones con abstracción de cuentas, desplegar contratos y operar las APIs de Fusebox a través de una interfaz de herramientas estándar.

Dos formas de usarlo:

Alojado en https://mcp.fuse.io/mcp — gratuito, solo lectura, configurado con las claves API de Fuse. Sin configuración más allá de apuntar tu agente a la URL.
Autoalojado mediante Docker o node dist/index.js — necesario para cualquier herramienta de escritura (debes controlar la clave privada) y para límites de tasa más altos.

Tres back-ends, en capas:

viem JSON-RPC — primitivas de cadena que cualquier nodo público puede servir, además de escrituras EOA (enviar FUSE, transferencias ERC-20, llamadas genéricas a contratos, despliegue de contratos, firma EIP-191 / EIP-712).
Fusebox Web SDK — APIs de lectura de valor añadido (precios de tokens, staking, cartera, historial de UserOp) y escrituras de cuentas inteligentes ERC-4337 mediante UserOperations (opcionalmente sin gas a través del paymaster de Fuse).
APIs REST de Fusebox — acceso directo a los endpoints de Notification, Smart Wallet, Trade y Explorer.

Instalación rápida para agentes de IA (alojado en mcp.fuse.io)

El endpoint alojado habla el transporte HTTP Streamable en https://mcp.fuse.io/mcp. Todas las herramientas de lectura están habilitadas; las de escritura no (necesitan una clave privada del lado del servidor — ver Autoalojamiento para escrituras más abajo).

Claude Code

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

Para eliminar más tarde: claude mcp remove fuse.

Cursor

Configuración → MCP → Añadir nuevo servidor, o edita ~/.cursor/mcp.json:

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

Claude Desktop

Claude Desktop actualmente lanza servidores MCP como subprocesos locales, por lo que habla con el endpoint alojado a través del puente mcp-remote. Edita ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows):

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

Reinicia Claude Desktop.

Continue (VS Code / JetBrains)

~/.continue/config.yaml:

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

Cline / Roo Code

Añade a través de la barra lateral MCP → "Add Remote Server", URL https://mcp.fuse.io/mcp. O edita ~/.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"] } }
  }
}

Cualquier otra cosa (cliente genérico Streamable HTTP)

Endpoint: https://mcp.fuse.io/mcp Transporte: Streamable HTTP (POST + actualización SSE opcional) Autenticación: ninguna en el endpoint alojado (es de solo lectura)

Autoalojamiento para escrituras

El endpoint alojado se ejecuta deliberadamente sin FUSE_PRIVATE_KEY — las herramientas de escritura se niegan a operar. Ejecuta tu propia instancia cuando necesites firmar transacciones, desplegar contratos o 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

Apunta tu agente a http://127.0.0.1:3000/mcp. Mismas configuraciones que arriba, cambiando la URL.

docker-compose

Coloca los secretos en un archivo .env junto a docker-compose.yml:

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

Luego:

docker compose up -d

Node directamente (modo stdio para clientes de subprocesos locales)

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

Para Claude Desktop / cualquier cliente que lance el servidor como subproceso:

{
  "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"
      }
    }
  }
}

Herramientas (v0.2) — 50 en total

Lecturas RPC — 8 (sin clave API requerida)

Herramienta	Descripción
`fuse_get_balance`	Saldo nativo de FUSE o ERC-20.
`fuse_get_transaction`	Obtener una transacción.
`fuse_get_receipt`	Obtener un recibo de transacción.
`fuse_read_contract`	Llamar a cualquier función view/pure (ABI obtenida automáticamente).
`fuse_get_token_metadata`	name / symbol / decimals / totalSupply.
`fuse_get_gas_price`	Precio actual del gas + sugerencias de tarifas EIP-1559.
`fuse_resolve_ens`	Resolver un nombre ENS (requiere `ENS_RPC_URL`).
`fuse_get_account_abstraction_info`	Estado ERC-4337 para una cuenta inteligente.

Lecturas del SDK de Fusebox — 10 (requiere `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 de Fusebox — 14 (requiere `FUSEBOX_PUBLIC_API_KEY`; Notification también necesita `FUSEBOX_SECRET_API_KEY`)

Notification (8): fuse_notification_{create,get,list_project,update,delete}_webhook, fuse_notification_{add,remove,list}_addresses. Smart Wallet (2): fuse_smart_wallet_authenticate, fuse_smart_wallet_get_actions. Trade (3, no SDK): fuse_trade_indicative_price, fuse_trade_liquidity_sources, fuse_trade_price_change_over_duration. Explorer (1 despachador genérico): fuse_explorer_query — cubre todos los 40+ endpoints estilo etherscan.

Escrituras EOA — 7 (requiere `FUSE_PRIVATE_KEY`)

Herramienta	Descripción
`fuse_get_signer_address`	Mostrar qué EOA controla el servidor.
`fuse_send_native`	Transferir FUSE nativo.
`fuse_send_erc20`	Transferir un ERC-20 (decimales auto-detectados).
`fuse_write_contract`	Llamada que muta estado (simula primero para mostrar razones de revert).
`fuse_deploy_contract`	Desplegar desde bytecode + ABI + args. Opcionalmente espera el recibo.
`fuse_sign_message`	Firma EIP-191 (`personal_sign`). Sin transmisión de tx.
`fuse_sign_typed_data`	Firma de datos estructurados EIP-712. Sin transmisión de tx.

Escrituras de cuentas inteligentes (UserOps ERC-4337) — 11 (requiere `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. Establece FUSE_USE_PAYMASTER=true para enrutar a través del paymaster de Fuse (sin gas).

Configuración

Variable	Predeterminado	Propósito
`MCP_TRANSPORT`	`stdio`	`stdio` (subproceso local) o `http` (Streamable HTTP para alojado/Docker).
`MCP_HTTP_HOST`	`0.0.0.0`	Host de enlace HTTP.
`MCP_HTTP_PORT`	`3000`	Puerto de escucha HTTP.
`MCP_HTTP_PATH`	`/mcp`	Ruta HTTP.
`FUSE_NETWORK`	`mainnet`	`mainnet` (cadena 122) o `spark` (testnet, cadena 123).
`FUSE_RPC_URL`	predeterminado de red	Sobrescribir el endpoint JSON-RPC.
`FUSE_EXPLORER_URL`	predeterminado de red	Sobrescribir la URL base del explorador Blockscout.
`FUSE_ENTRYPOINT_ADDRESS`	ERC-4337 v0.7 canónico	Sobrescribir el EntryPoint.
`ENS_RPC_URL`	sin establecer	RPC de Ethereum mainnet para resolución de `.eth`.
`FUSEBOX_PUBLIC_API_KEY`	sin establecer	Clave API pública — requerida para herramientas SDK + REST + cuentas inteligentes.
`FUSEBOX_SECRET_API_KEY`	sin establecer	Clave API secreta (cabecera `API-SECRET`). Requerida solo por las herramientas de la API Notification.
`FUSEBOX_BASE_URL`	predeterminado del SDK	Sobrescribir el host de la API Fusebox del SDK.
`FUSEBOX_API_ORIGIN`	`https://api.fuse.io`	Sobrescribir el origen de la API Fusebox del cliente HTTP crudo.
`FUSE_PRIVATE_KEY`	sin establecer	Clave privada hexadecimal de 32 bytes para el firmante. Requerida por cada herramienta de escritura. Se lee una vez al inicio; nunca se acepta como argumento de herramienta.
`FUSE_USE_PAYMASTER`	`false`	Cuando `true`, los UserOps de cuentas inteligentes se enrutan a través del paymaster de Fuse (sin gas).

Modelo de seguridad

Manejo de claves. Las claves privadas viven solo en el entorno del servidor. Nunca se aceptan como argumentos de herramienta — eso las filtraría en la transcripción de la conversación del agente. El servidor lee FUSE_PRIVATE_KEY una vez al inicio y firma localmente.
Endpoint alojado. https://mcp.fuse.io/mcp no tiene FUSE_PRIVATE_KEY configurado. Las herramientas de escritura devuelven un error accionable que apunta a los usuarios al autoalojamiento. La clave pública de Fusebox incluida allí tiene límite de tasa para compartir de manera justa.
Producción autoalojada. Trata el servidor como un firmante de hot-wallet. Ejecútalo junto a tu aplicación, restringe el ingreso, financia la EOA con el mínimo de FUSE que estés dispuesto a perder ante un incidente de inyección de prompts, y prefiere el paymaster (FUSE_USE_PAYMASTER=true) para que la smart wallet pueda transaccionar sin mantener gas.

Estructura del proyecto

.
├── 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)