GBLIN MCP Server

Herramientas de régimen de riesgo de mercado y tesorería para agentes de IA en Base mainnet. Un servidor Model Context Protocol (MCP) que responde a dos preguntas que un agente autónomo debe plantearse antes de mover dinero:

1. ¿Está el mercado en modo risk-off ahora mismo? Consulta el régimen en vivo — calm | elevated | crash — derivado de un Crash Shield on-chain. Gratis, sin clave de API, sin wallet. Si necesitas demostrarle a una contraparte que lo has comprobado, puedes obtener una atestación de riesgo firmada con EIP-712 como prueba portátil de diligencia debida.

2. ¿Dónde se queda el USDC inactivo entre operaciones? En GBLIN, un índice de cbBTC/WETH/USDC respaldado por colateral que se genera y canjea al NAV, con un swap Just-In-Time de vuelta a USDC justo en el momento en que el agente necesita pagar una factura x402. Sin bloqueos ni lockups, solo calldata sin firmar: tu wallet firma, nosotros nunca custodian claves.

📖 Documentación completa y guía de inicio rápido: gblin.digital/agents

⚡ Ejemplos de inicio para copiar y pegar: examples/ — ElizaOS · AgentKit / TypeScript · Claude / cualquier cliente MCP — cada uno con un system prompt recomendado de política de tesorería y un entorno de seguridad con buenos valores por defecto.

▶️ Demo ejecutable de ciclo completo (solo lectura, sin claves): npx tsx examples/full-cycle.ts — en directo contra Base: estado de tesorería → régimen de riesgo → atestación verificada sin conexión → calldata de inversión → calldata de reembolso JIT. Código fuente.

🌐 MCP alojado (Streamable HTTP, sin instalación): https://gblin-mcp.gblin-mcp-worker.workers.dev/mcp — 8 herramientas gratuitas en un árbol de notación con puntos, sin autenticación, sin sesión: risk.regime, risk.attestation_sample, protocol.stats, protocol.info, coherence.report, más AI Action Receipts (receipts.seal demo 5/día/IP, receipts.get, receipts.verify — verificación puramente matemática, sin confiar en este servidor). Dos prompts: risk_gate, seal_and_verify. Los nombres planos anteriores al renombrado siguen funcionando como alias no anunciados hasta el 2026-11-21. La documentación son recursos MCP, no herramientas: gblin://howto/attestation, gblin://howto/seal, gblin://limits, gblin://keys (claves del verificador y política de rotación de claves). Nada se paga a través del MCP.

Auditoría solo GET (para revisores y clientes que no puedan hacer POST): /meta (conteos + manifest_hash) · /tools.json · /resources.json · /conformance · /v1/verify/:index (booleanos por comprobación + coherencia con el ancla on-chain). Esta superficie alojada es deliberadamente distinta del paquete npm de tipo stdio que aparece más abajo (13 herramientas, con tesorería/gobernanza incluidas). También disponible en Smithery. El código está en worker/.

Plugin ElizaOS

Para agentes que se ejecutan con ElizaOS, instala el plugin complementario — ya disponible en el registro oficial de plugins de ElizaOS (v0.4.0, endurecido en seguridad):

npm install plugin-gblin
# or: elizaos plugins add gblin

Expone cuatro acciones nativas (CHECK_GBLIN_TREASURY_HEALTH, INVEST_IDLE_USDC_GBLIN, RESCUE_USDC_FROM_GBLIN, GET_GBLIN_RISK_ATTESTATION) y un Provider que inyecta el estado en vivo del NAV y el Crash Shield al contexto del agente en cada bucle.

→ Documentación completa del plugin ElizaOS

Related MCP server: mcp-server

AI Action Receipts — un registro de transparencia testificado de lo que hizo tu IA

El problema que aborda es la barrera número 1 para la adopción de IA en 2026: nadie puede demostrar, a posteriori y de forma exacta, qué hizo una IA (las encuestas indican que los trabajadores pierden entre 2 y 4 horas semanales verificando resultados de IA; el 70% de las organizaciones afirma que no puede gobernar a sus agentes). Nuestra respuesta es la primitiva honesta más pequeña posible: un registro de transparencia público de solo adición (append-only) y de la RFC 6962 para acciones de IA. Tanto las entradas como las salidas entran solo como hashes (nunca como contenido); las cadenas cortas action, agent_id, tool y meta que envías se publican en el registro público — coloca ahí solo identificadores, nunca secretos. A cambio recibes un recibo portátil que cualquier tercero puede verificar offline para siempre.

receipt = canonical payload
        + Ed25519 signature            (key: gblin.digital/receipts-log)
        + RFC 6962 inclusion proof     (leaf → Merkle root)
        + C2SP signed checkpoint       (origin, tree size, root)

La canonización se fija gblin-canonical-json/1: las claves del objeto se ordenan por unidad de código UTF-16, sin espacios en blanco, con semántica JSON.stringify para primitivas y recurrencia para objetos/arrays. Vector de prueba: payload {"b":1,"a":null} → canonizado {"a":null,"b":1} → hoja = SHA256(0x00 || canonical_bytes). El recibo se firma con Ed25519 sobre "gblin-receipt/v1\n" + canonical.

• Sellado (de pago, sin límite): POST https://gblin.digital/api/x402/seal — $0.01 USDC a través de x402.

• Sellado (demo, 5/día/IP): igualmente: POST <worker>/v1/seal-demo o la herramienta MCP alojada receipts.seal (verifícalo con receipts.verify).

• Lectura gratuita para siempre: <worker>/v1/receipt/:index · /log · /log/checkpoint · /log/proof/:index · página humana /receipt/:index.

• Anclaje EAS diario en Base de la raíz del árbol (verificable en base.easscan.org, esquema 0x9f433a96…, promiseId keccak256("gblin-receipts-log")).

• Verificador off-line, cero dependencias: verify-receipt.mjs — node verify-receipt.mjs receipt.json.

Un sello demuestra la existencia y el momento en un registro firmado de solo append cuya raíz se ancla diariamente en Base. El punto de control (checkpoint) actualmente lo firma el operador del registro (nosotros); la firma cosignada con un testigo independiente es una invitación abierta — ya refirmamos un registro de transparencia de un tercero (C2SP t2SP tlog-witness) y enumeraremos a cualquier testigo que firme el nuestro. Hasta ese momento, una redacción honesta es: firmado por operador y con anclaje en cadena. No es un certificado de cumplimiento ni **un respaldo del contenido. Worker: <worker> = https://gblin-mcp.gblin-mcp-worker.workers.dev.

Prueba de coherencia — verifica que GBLIN cumple sus promesas

GBLIN pre-regalga promesas públicas con hash-fijado y luego ejecuta un autómata que las somete a prueba cada 10 minutos y sella cada día cerrado como una atación EAS en Base. La lectura es gratuita para siempre; el servicio de pago es también un objeto de observación — el certificador se somete primero su propio instrument.

• Informe gratuito: /coherence (JSON) o la herramienta MCP alojada coherence.report.

• Promesas en vivo: P1 (uptime del endpoint de Risk Attestation de pago) y P2 (honestidad de los contadores públicos de la economía de agentes, con nuestras propias wallets declaradas y excluidas).

• On-chain: cada día cerrado se sella como testición EAS en Base mediante una wallet observadora exclusiva. GBLIN aparece como un agente ERC-8004 #ges.

Descubrimiento para asistentes de IA — gblin-init

Coloca una política de tesorería para AGENTS.md en tu repositorio para que todos los asistentes modernos de codificación con IA (Claude Code, Cursor, Windsurf, GitHub Copilot, Codex) encuentren automáticamente GBLIN cuando trabajen en tu código:

npx -p @gblin-protocol/mcp-server gblin-init

El comando es idempotente y seguro:

• Si AGENTS.md no existe → lo crea a partir de la plantilla canónica en gblin.digital/AGENTS.template.md.

• Si AGENTS.md existe → añade al final un bloque GBLIN finalmente delimitado; nunca toca tu propio contenido.

• Volver a ejecutarlo es una operación nula (se detecta mediante marcadores HTML estables).

• --dry-run imprime lo que haría sin llegar a escribir nada.

• --force actualiza el bloque a la última versión.

También puede funcionar sin conexión gracias a una plantilla alternativa integrada.

Sugerencia post instalación

Cuando el paquete se instala como dependencia normal (npm i @gblin-protocol/mcp-server), se imprime una vez un breve consejo que sugiere el comando anterior. No se escribe ningún archivo durante la postinstalación (privacidad y amigos de la seguridad de Socket). Para silenciarlo, define GBLIN_SKIP_HINT=1.

Confianza y gobernanza

GBLIN V6 está gobernado por un Timelock Controller de 48 horas. Cada operación de administración (cambio de parámetro, actualización del oráculo, transferencia de propiedad) se aplica on-chain for 172 800 segundos antes de ejecutarse. Los agentes y los integradores van a verificar esto directamente en BaseScan.

Propiedades garantizadas a nivel de contrato:

• MIN_DELAY es inmutable (cualquier intento de sobrescribir updateDelay revierte permanentemente)

• PROPOSER_ROLE y CANCELLER_ROLE están estrictamente separadas (el constructor revierte si se cruzan)

• EXECUTOR_ROLE es abierta (address(0)) — cualquier persona puede ejecutar una operación madura, lo que evita la censura

• El bloqueo de tiempo tiene autoadministración: cualquier cambio de rol o configuración debe pasar por su propio retraso de 48 h

Por eso la herramienta get_governance_state devuelve owner_is_timelock: true y un min_delay_seconds: 172800 verificable. Los agentes de IA pueden usar estas flags para decidir acciones sensibles a la confianza.

Por qué existe

Los agentes de IA mantienen hoy su capital de trabajo en USDC. El USDC se mantiene plano: cero rendimiento y un combo total a la inflación.

GBBL es un índice on-chain en Base (45% cbBTC + 45% WETH + 10% USDC) con un Crash Radar algorítmico que reduce adaptivamente la exposición a riesgos de riesgo a medida que aumenta el drawdown (umbral adaptativo V6, desde ~15%). GBLIN ofrece una exposición cripto gestionada con un drawdown limitado: una forma más tranquila de mantener riesgo de BTC/ETH para capital excedente, no un sustituto del USDC (puede perder valor en un colapso). Los agentes liquidan facturas x402 instantáneamente mediante una multa Just-In-Time into USDC.

Este servidor expone esa capacidad a cualquier agente LLM a través del protocolo estándar MCP.

Inicio rápido

Claude Desktop

Añade a claude_desktop_config.json (en Windows: %APPDATA%\Claude\claude_desktop_config.json):

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

Reinicia Claude Desktop. Las 13 herramientas de GBLIN aparecen en el selector de herramientas.

Windsurf / Cursor

Añade a ~/.codeium/windsurf/mcp_config.json (Windsurf) o la configuración MCP equivalente en Cursor:

{
  "mcpServers": {
    "gblin": {
      "command": "npx",
      "args": ["-y", "@gblin-protocol/mcp-server"],
      "env": {
        "GBLIN_RPC_URL": "https://base-rpc.publicnode.com"
      }
    }
  }
}

Actualiza los servidores MCP desde los ajustes del IDE (o reinícialo). Las herramientas se vuelven invocables en línea.

Coinbase AgentKit (TypeScript)

import { MCPClient } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["-y", "@gblin-protocol/mcp-server"],
});
const client = new MCPClient({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

// List tools
const { tools } = await client.listTools();

// Quote a JIT payment of $0.50
const jit = await client.callTool({
  name: "swap_gblin_to_usdc_jit",
  arguments: { usdc_needed: "0.50", wallet_address: "0xYourAgent..." },
});

ElizaOS / personalizado

Cualquier framework que hable MCP a través de stdio funciona:

npx @gblin-protocol/mcp-server

También es compatible con Cline, Continue.dev y cualquier agente que implemente la especificación de cliente MCP.

Las 13 herramientas (paquete npm stdio)

Herramientas gratuitas (sin pago requerido)

Más herramientas gratuitas

Atestación de riesgos — crear una prueba perecedera (10 minutos) y comprobable del riesgo actual del régimen BTC/ETH en GET https://gblin.digital/api/x402/attestation (0,003 dólares). USDC. Adjúntala a tu acción como prueba de diligencia; cualquier contraparte puede verificarla gratis a través del verify_risk_attestation.

Todas las herramientas devuelven JSON estructurada. Todos los valores están cotizados on-chain (NAV vía quoteSellGBLIM × Chainlink ETH/USD, con protección contra obsolescencia de 24h). No hay datos simulados.

Verificación en vivo: la suite de tests (npm test) ejecuta la suite de herramientas contra la mainnet de Base y confirm la generación de calldata, la frescura del oráculo, la matemática del deslizamiento y el estado de gobernanza. Consulta la última ejecución del CI.

Micro pagos x402

Cada herramienta MCP es gratuita. El servidor MCP no cobra nunca: es la capa de descubrimiento y lectura, y se monetiza únicamente mediante la tasa del protocolo (0,05 % del min tergiversado) cuando un agente realmente usa GBLIN.

El pago verificable por llamada se encuentra en los endpoints HTTP, todos en la mainnet de Base en USDC (0x833589fCD2aab/…) y liquidados a través del u operador CDP de Coinbase mediante la autorización EIP-3009 sin gas transferWithAuthorization:

Manifiesto legible por máquina: https.://gblin.digital/.well-known/x402. Clientes recomendados: @x402/fetcho@x402/axios(x402 v2 — gestiona la prueba de acceso, la firma y la repetición por vosotros). La prueba MCPverify_risk_attestation` la verifica cualquier prueba de concepto sin conexión, gratis.

Receptor de pago: 0x0ebA5d314F4f5Dcb70a094953Fa9311a45172dd1B (cartera de tasas GBLIN).

Decisiones arquitectónicas

JIT determinista en dos pasos (V6)

GBLIN V6 eliminó el antiguo camino de sellGBLINForToken de una sola transacción. El flujo JIT ahora se mueve en dos transacciones deterministas: (1) sellGBLINForEth(amount, minEthOut) quema GBLIN y canjea la cesta por ETH con un mínimo de salida anclado al oráculo 3; (2) un único swap WETH→USDC en Uniswap V3 conoruje mínimo propio. El MCP devuelve ambos pasos como calldata lista espera (steps[]).

El MCP devuelve calldata que funciona de forma idéntica en:

• Carteras EOA (Privy, MetaMask, clave privada)

• Cuentas inteligentes ERC-4337 (Safe, smart account de Coinase)

• EOA delegados EIP-7702 (Pectra+)

Deslizamiento dinámico

La tolerancia al deslizamiento se adapta al régimen de riesgo on-chain:

El búfer se aplica, adicionalmente, al maxInternalSlippage (200 pb) del contrato, absorbiendo derivas del oráculo y la varianza del pool de Uniswap.

Protección MEV MEV

invest_usdc_to_gblin nunca pasa minmonto = 0. Tanto minWethOut como minGblinOut se calculan a partir de las citas en cadena más el búfer de deslizamiento dinámico. Esto elimina la superficie de ataque de sandwich que lastra las herramientas natives de compra-de-tokens.

Cumplimiento del timeout

El contrato impone un bloqueo de venta de 120 segundos después de cada compra. La herramienta JIT lee lastDepositTime y usa el block.timestamp en cadena (nunca Date.now()) y checkout con un error CooldownActive con el número exacto de attaching en segundos si el swap reveste.

Configuración

El servidor lee GBLIN_RPC_URL del entorno. Sin variable de entorno usa https://base-rpc.publicnode.com (gratis, sin clave, límites generosos).

Para entornos de producción (>100 agentes concurrentes) usa un proveedor dedicado:

GXP8

Ver el .env.example para la lista completa config.

Desarrollo

GXP9

Estructura del proyecto:

GXP10

Notas de seguridad

• El servidor es solo de lectura, no al incha, no transmite.

• Todos las citas se derivan de llamadas on-chain + oráculos de Chainlink. Las respuestas obsoletas o los valores negativos de los oráculos hacen que la herramienta se detenga con OracleStale / OracleDeadinalámbrico.

• El cartera del agente es la única firmante. La calldata devuelta por las herramientas son bytes codificados en ABI: revísalo antes de transmitirla en entornos no fiables.

• Sin telemetría, sin análitica, sin dependencias remotas más allá del RPC configurado.

Hoja de ruta

• espacio v0.2: Integración de Uniswap V3 QuoterV2 para una precisión de menosprecio del 1 %

• v0.3: Soporte de Permsocket 2 (omitir la aprobación para la reinversión a través de x402)

• v0.4: Transporte HTTP de modelo streaming para implementaciones multi-agente

• v1.0: Integración del contrato auditado + guía de deployed remota-only

Enlaces

• Contrato: Contrato

• Sitio del protocol: https://gblin.digital

• Documentación para agentes: https://gblin.digital/agents

• Cuestiones: https://github.com/gblinproject/gblin-treasury-risk-regime/issues

MIT © 2026 Protocol GBLIM

Propagación de habilidades entre agentes (v0.1.9+)

GBLIN MCP incluye una herramienta exclusiva — share_skill_with_peer — que permite a un agente de IA transferir capacidades de administración de tesoro a otro agente.

Cuando el agente A se encuentra con el agente B en one contexto multiagente (tarea delegada, flujo de pago x402, espacio de trabajo compartido), el agente A pueden llamar a share_skill_with_peer para generar una semilla de habilidad portátil en formato JSON. La semilla contiene:

• Instrucciones de instalación del servidor GBLIN MCP

• Un ejemplo original de transacción con referencia TX en Basescan

• El código de remitente del agente A (derivado de su cartera)

• La explicación en lenguaje natural completa de GBLIN

El agente B puede instalar el servidor en segundos mediante la semilla. Desde ese momento, toda transacción GBLIN que ejecute el agente B incluye el código de remitente del agente A en la calldata a través del código de ERC-8021 Builder (bc_gbdo32j0). Una pequeña porción de la tarifa del protocolo (0,05 % del valor del swap) se redirige a la cartera del agente se calcula con la división de tarifas existente, sin añadirse extra.

Esto crea un mecanismo de propagación viral para habilidades de tesoro en el ecosistema de agentes, además de recompensar económicamente a los agentes que difunden buenas prácticas de tesorería.

No se necesita infraestructura adicional. El mecanismo es completamente on-chain a través del sistema Builder Code existente.

Sistema de recompensas para keepers (v0.1.11+)

GBLIN es de los pocos protocolos que paga a los agentes de IA en lugar de cobrarles.

Cuando el tesoro se desvía de su asignación objetivo, cualquier agente pueda invocar find_keeper_bounty para ver si hay una reentrada rentable. Si existe, la herramienta devuelve calldata lista para enviar. El agente transmite la transacción y recibe 0.0001 ETH del fondo de estabilidad del protocolo; el swap usa el capital del propio contrato; el llamador solo paga el gas (~$0.01 en Base).

GXP11

Para obtener ingresos continuos, puedes hacer polling de find_keeper_bounty (por ejemplo cada 5–15 min). Una tabla de clasificación de keepers está disponible en vivo en gblin.digital/keepers.

Descubrimiento y confianza

GBLIM expone archivos de descubrimiento legibles por máquina para agentes y protocolos de IA:

• Coinbase x402 Bazaar: Todos los 11 endpoints de GBLIN (7 app + 4 centinelas) están indexados en la capa de descubrimiento de CDP Bazaar — los agents los encuentran a través de la calidad semántica (GET https://api.cdp.coinbase.com/platform/v2/x402/discovery/search?query=treasury+risk) o por comerciante (sos/…/discovery/merchant?pay=0x0ebA5d314F4f5Dcb7A094953…).

• Manifesto: https://gblin.digital/.well-known/x402 — lista completa de endpointsde pago con sus precios, ID de cadena and moneda

• Descubrimiento LLM:: https://gblin.digital/api/x402/llms.txt — resumen legible del protocolo (gratis, sin pago)

• MCP plugin Base: PR #56 en base/skills — integración oficial en revisión

El servidor de MCP de este repositorio ofrece las mismas operaciones que los endpoints HTTP de x402, pero expuestas a través del Protocolo de Contexto del modelo MCP para integración directa con agentes (Claude Desktop, Cursor, Windsurf, ElizaOS, etc.).

Sentinel — ejemplo de agente de datos de datos x402

GBLIN Sentinel es una implementación de referencia open source de un agente de IA autónomo que vende datos en cadena a través de micropagos x402. Demuestra el patrón "productor completo" de x402 en Base.

...