Este tutorial está diseñado para guiar a quienes desean aprender más acerca de The Graph. Es ideal para un nivel medio.
The Graph es un protocolo descentralizado esencial para indexar y consultar datos de blockchains como Ethereum, Polygon, BNB Chain, Arbitrum y muchas otras, facilitando a los desarrolladores acceder a información de contratos inteligentes de forma rápida y estructurada. Permite crear 'subgraphs', que son APIs abiertas y personalizadas que definen qué datos indexar de la blockchain (eventos, llamadas de función, estado) y cómo transformarlos en un esquema de datos consultable usando GraphQL. Esta guía de nivel intermedio profundiza en los componentes de un subgraph (manifest `subgraph.yaml`, esquema `schema.graphql`, manejadores de datos en AssemblyScript `mapping.ts`), el funcionamiento del proceso de indexación en Graph Node, la arquitectura de la red descentralizada de The Graph (Indexers, Curators, Delegators) y el rol del token GRT. Cubre el uso de la CLI de The Graph para inicializar, construir y desplegar subgraphs (tanto al Hosted Service como a la red descentralizada), la escritura de manejadores de eventos y llamadas, la definición de entidades de datos, y cómo realizar consultas eficientes usando GraphQL para alimentar aplicaciones Web3.
El 'Hola, mundo' de The Graph: un subgraph básico que define una entidad simple en el esquema y un manejador de eventos en AssemblyScript para indexar datos de un evento de contrato inteligente.
# schema.graphql
type Greeting @entity {
id: ID!
greeting: String!
sender: Bytes! # address as Bytes
blockTimestamp: BigInt!
transactionHash: Bytes!
}
# src/mapping.ts (AssemblyScript handler for a hypothetical 'NewGreeting' event)
import { NewGreeting } from '../generated/YourContractName/YourContractName'; // Importa el tipo de evento
import { Greeting } from '../generated/schema'; // Importa la entidad generada
export function handleNewGreeting(event: NewGreeting): void {
// Crea una nueva instancia de la entidad Greeting usando el hash de transacción como ID
let greeting = new Greeting(event.transaction.hash.toHex());
// Asigna los datos del evento a las propiedades de la entidad
greeting.greeting = event.params.greeting;
greeting.sender = event.params.sender;
greeting.blockTimestamp = event.block.timestamp;
greeting.transactionHash = event.transaction.hash;
// Guarda la entidad en el almacenamiento indexado
greeting.save();
}
# subgraph.yaml (Fragmento relevante para el evento)
# ... otras configuraciones ...
source: # Contrato a monitorear
address: "0x..." # Direccion de tu contrato
abi: "YourContractName"
startBlock: 12345678 # Bloque desde donde empezar a indexar
entities:
- Greeting # La entidad definida en schema.graphql
features:
#- ipfs # Opcional, si usas ipfs en mappings
mapping:
kind: ethereum/events
apiVersion: 0.0.7
language: assemblyscript
entities:
- Greeting
abis:
- name: YourContractName
file: ./abis/YourContractName.json # ABI de tu contrato
eventHandlers:
- event: NewGreeting(string,indexed address) # Nombre y tipos de los parámetros del evento
handler: handleNewGreeting # La funcion manejadora en mapping.ts
file: ./src/mapping.ts # Archivo de mapeo
Resultado:
Define un subgraph que indexa un evento 'NewGreeting' de un contrato. Cada vez que se emite el evento, se crea una entidad 'Greeting' con los datos relevantes, haciéndola consultable a través de GraphQL.
Familiarizarse con estos comandos es esencial para interactuar eficientemente con The Graph:
npm install -g @graphprotocol/graph-cli
graph auth --product hosted-service https://api.thegraph.com/deploy/ <TU_ACCESS_TOKEN>
graph auth --product subgraph-studio https://api.studio.thegraph.com/deploy/ <TU_API_KEY_SUBGRAPH_STUDIO>
graph init
Editar el archivo `schema.graphql`. Define tus 'Entities' (entidades) y sus campos utilizando la sintaxis de GraphQL. Las entidades son como tablas en una base de datos y representan los objetos que tu subgraph indexará.
Editar el archivo `subgraph.yaml`. Este archivo define la cadena a monitorear, las direcciones de los contratos, los eventos o llamadas de función a escuchar, el bloque de inicio de la indexación, y la ruta a los archivos de esquema y mapeo.
Editar los archivos `.ts` en la carpeta `src/` (por defecto `mapping.ts`). Aquí implementas las funciones que se ejecutan cuando se disparan eventos o llamadas a funciones en la blockchain. Estas funciones (escritas en AssemblyScript) transforman los datos brutos de la blockchain en las entidades definidas en tu `schema.graphql` y las guardan en la base de datos indexada.
graph codegen
graph build
graph deploy --product hosted-service <USUARIO_HOSTED_SERVICE>/<NOMBRE_SUBGRAPH> --version v0.0.1
graph deploy --product subgraph-studio <NOMBRE_SUBGRAPH> --version v0.0.1
Ir a la página de tu subgraph en el Hosted Service (thegraph.com/hosted-service/...) o Subgraph Studio (thegraph.com/studio/...) -> 'Query'. Usa la interfaz para escribir y ejecutar consultas GraphQL sobre tus datos indexados.
En la página de tu subgraph en el Graph Explorer (Hosted Service o Red Descentralizada), verás información como el estado de sincronización ('Sync Status' o porcentaje), el bloque actual indexado, el bloque de inicio, y detalles sobre los errores de indexación si los hay.
graph deploy --product hosted-service <USUARIO>/<NOMBRE_SUBGRAPH> --version v0.0.<NUEVA_VERSION>
npm test
Comprender estos conceptos fundamentales te ayudará a dominar The Graph de forma más organizada y eficiente:
Protocolo de Indexación Descentralizado:
The Graph es un protocolo abierto que permite a los desarrolladores construir y publicar APIs (subgraphs) para indexar datos de blockchains de forma descentralizada. Esto permite acceder a datos históricos o estructurados de la blockchain de forma rápida y eficiente, lo cual es un desafío significativo al interactuar directamente con nodos RPC.
Subgraphs (Manifest, Schema, Mappings):
La unidad fundamental en The Graph. Un subgraph es una API definida por el usuario que especifica qué datos de la blockchain indexar y cómo transformarlos. Se define en tres archivos clave: el Manifest (`subgraph.yaml`) que indica qué cadena, contratos, eventos/llamadas escuchar; el Schema (`schema.graphql`) que define la estructura de los datos indexados; y los Mappings (`mapping.ts` en AssemblyScript) que contienen la lógica de transformación de datos.
Graph Node:
El software de código abierto que ejecuta subgraphs. Se conecta a un nodo de blockchain, lee los bloques, escucha los eventos y llamadas especificados en el manifest, ejecuta los manejadores de mapeo (compilados a WebAssembly) para procesar los datos y guarda los resultados en una base de datos (PostgreSQL).
The Graph Network (Indexers, Curators, Delegators):
La red descentralizada de The Graph donde operan los subgraphs. Los Indexers son operadores de nodos que hacen staking de GRT para indexar subgraphs y servir consultas. Los Curators señalan subgraphs valiosos haciendo staking de GRT, guiando a los Indexers. Los Delegators participan delegando su GRT a Indexers para ganar una parte de las tarifas y recompensas. Esta red incentiva la provisión de servicios de indexación y consulta de forma descentralizada.
GRT Token:
El token nativo de utilidad de The Graph Network. Se utiliza como staking (Indexers), señalización (Curators) y delegación (Delegators) para coordinar la actividad en la red y asegurar que los datos indexados sean correctos y estén disponibles para consultas. Los usuarios que consultan subgraphs pagan tarifas en GRT a los Indexers.
GraphQL:
El lenguaje de consulta utilizado para interactuar con los subgraphs indexados. Permite solicitar exactamente los campos de datos que necesitas de tus entidades definidas en el esquema, optimizando el ancho de banda y la velocidad de las consultas en comparación con las llamadas RPC de bajo nivel.
Hosted Service vs Red Descentralizada:
Dos opciones de despliegue y consulta. El Hosted Service (hosted-service.thegraph.com) es una plataforma centralizada y gratuita (con límites) para desarrollo y pruebas. La Red Descentralizada (operada por Indexers de la red, accesible vía Subgraph Studio) es la visión a largo plazo para una infraestructura de indexación resiliente y descentralizada, donde se pagan tarifas en GRT por las consultas.
Proceso de Indexación y Estado de Sincronización:
Después de desplegar un subgraph, Graph Node comienza a leer los bloques de la cadena desde el bloque de inicio especificado, ejecutando los manejadores de mapeo para cada evento/llamada relevante. El 'Sync Status' muestra el progreso, indicando hasta qué bloque el subgraph ha procesado la cadena. Un subgraph debe estar sincronizado ('Synced') para reflejar el estado más reciente de la blockchain.
AssemblyScript para Mappings:
El lenguaje utilizado para escribir los manejadores de datos en los subgraphs. AssemblyScript es un subconjunto de TypeScript que compila a WebAssembly (`.wasm`). Esto permite ejecutar la lógica de mapeo de forma segura y eficiente dentro de Graph Node.
Entidades y Relaciones en el Esquema GraphQL:
Las 'Entities' en tu `schema.graphql` representan los tipos de objetos de datos que estás indexando (ej: `User`, `Token`, `Trade`). Defines sus campos y tipos. Puedes establecer relaciones entre entidades (ej: un `User` tiene muchos `Trade`s) para consultas GraphQL más complejas.
Manejadores de Eventos y Llamadas:
Los manejadores de mapeo pueden configurarse para responder a eventos específicos emitidos por contratos (más común y eficiente) o a llamadas de función a contratos. Reciben los datos brutos del evento/llamada y ejecutan lógica para crear, actualizar o eliminar entidades indexadas.
Consultando Subgraphs:
Una vez que un subgraph está sincronizado, su endpoint GraphQL (obtenido del Graph Explorer) se puede usar para consultar los datos indexados desde cualquier aplicación (frontend, backend) utilizando librerías GraphQL. Las consultas definen exactamente qué datos se necesitan y en qué formato.
Importancia para dApps Eficientes:
The Graph es crucial para dApps que necesitan mostrar datos históricos o agregados a los usuarios. Permite que el frontend obtenga la información necesaria con una única consulta GraphQL rápida, en lugar de hacer múltiples llamadas RPC costosas e ineficientes a un nodo blockchain, mejorando significativamente el rendimiento y la experiencia del usuario.
Algunos ejemplos de aplicaciones prácticas donde se utiliza The Graph:
Crear APIs personalizadas basadas en eventos y estado de contratos inteligentes para alimentar interfaces de usuario de dApps:
Diseñar subgraphs que indexan eventos clave (ej: `Transfer`, `Approval`, `Mint`), propiedades importantes de contratos (`totalSupply`, `balanceOf`) y metadatos (NFTs) para proporcionar datos estructurados y eficientes que tu frontend de dApp pueda consultar rápidamente via GraphQL.
Construir dashboards, herramientas de análisis o plataformas de datos sobre protocolos DeFi, marketplaces de NFTs o DAOs:
Utilizar The Graph para indexar grandes volúmenes de datos históricos de protocolos complejos y luego consultarlos de forma eficiente con GraphQL para crear interfaces informativas, herramientas de análisis de mercado o reportes sobre la actividad on-chain.
Proporcionar acceso rápido y estructurado a datos históricos de la blockchain que son difíciles de obtener directamente de nodos RPC:
Usar subgraphs para indexar eventos o estado de contratos de hace mucho tiempo, permitiendo consultas rápidas sobre datos históricos que serían muy lentas o imposibles de obtener eficientemente haciendo 'polling' o recorriendo bloques con llamadas RPC a un nodo.
Indexar datos de múltiples contratos inteligentes relacionados en un solo subgraph para una API unificada:
Combinar la indexación de eventos, llamadas y estado de varios contratos que interactúan entre sí (ej: un token ERC-20, un contrato de staking y un contrato de gobernanza) en un único subgraph para tener una API GraphQL centralizada para todos los datos relevantes del protocolo.
Implementar funcionalidades de búsqueda, filtrado y ordenamiento complejas sobre datos on-chain en dApps:
Utilizar las capacidades de consulta avanzada de GraphQL (filtros, ordenamiento, paginación) sobre los datos indexados por tu subgraph para permitir a los usuarios buscar (ej: por dirección), filtrar (ej: transacciones mayores a X), u ordenar (ej: por fecha) datos on-chain de forma eficiente en el frontend de una dApp.
Integrar datos indexados de la blockchain en servicios backend:
Consultar los endpoints GraphQL de subgraphs desde servicios backend (en Node.js, Python, etc.) para obtener datos on-chain de forma eficiente para la lógica de negocio, sincronización con bases de datos off-chain, o para activar flujos de trabajo basados en datos de la blockchain.
Construir interfaces de usuario que muestran listas de eventos recientes o actividad histórica de contratos:
Usar subgraphs para obtener fácilmente listas paginadas y ordenadas cronológicamente de eventos de contratos (ej: últimas transferencias de un token, historial de votaciones de un DAO) para mostrar en feeds o tablas en el frontend de una dApp.
Simplificar la recuperación y estructuración de metadatos de NFTs y otra información asociada al token:
Indexar eventos de mint y transferencia de NFTs y usar los manejadores de mapeo para obtener y estructurar los metadatos (a menudo almacenados en IPFS) asociados a cada token ID, facilitando que las dApps muestren información detallada sobre los NFTs.
Monitorizar y analizar la actividad de contratos inteligentes de forma detallada:
Utilizar los datos indexados en un subgraph para obtener insights sobre el uso de contratos, el número de usuarios, el volumen de transacciones, etc., consultando directamente los datos estructurados en el subgraph en lugar de realizar análisis complejos directamente sobre la blockchain.
Desplegar a la Red Descentralizada para mayor Resiliencia y Descentralización:
Una vez que un subgraph esté maduro y probado en el Hosted Service, desplegarlo a la Red Descentralizada a través del Subgraph Studio para que sea indexado por múltiples Indexers independientes, aumentando su fiabilidad y resistencia a la censura para dApps de producción.
Aquí tienes algunas recomendaciones para facilitar tus inicios en The Graph:
Entiende Por Qué la Indexación es Crucial para dApps Eficientes:
Leer datos históricos o filtrar eventos directamente desde un nodo blockchain es lento y ineficiente. The Graph resuelve esto indexando los datos relevantes. Entender esta necesidad fundamental te ayudará a apreciar el valor de The Graph.
Familiarízate con los Tres Pilares de un Subgraph: Manifest, Schema y Mappings:
Un subgraph es una definición. Aprende qué papel juega cada archivo clave: `subgraph.yaml` (configura qué indexar), `schema.graphql` (define la estructura de tus datos indexados) y `mapping.ts` (la lógica para transformar datos brutos en tus entidades).
Usa la CLI de The Graph para Todo el Proceso:
La herramienta `@graphprotocol/graph-cli` es tu interfaz principal. Aprende a usar `graph init` (para empezar), `graph codegen` (para generar clases de datos), `graph build` (para compilar) y `graph deploy` (para publicarlo).
Empieza Creando un Subgraph Simple desde un Contrato Existente:
La forma más fácil de empezar es usar `graph init --from-contract <DIRECCION> <NOMBRE> --network <RED>`. La CLI analizará tu contrato y generará un esqueleto de subgraph con manejadores básicos para sus eventos. Luego, modifícalo para tus necesidades.
Domina la Escritura de Manejadores de Mapeo en AssemblyScript:
Esta es la parte principal donde escribes código. Aprende cómo las funciones en `mapping.ts` reciben datos de eventos/llamadas, cómo usar las clases generadas por `graph codegen` para crear/actualizar entidades, y cómo guardarlas (`entity.save()`).
Utiliza el Graph Explorer para Probar Tus Consultas GraphQL:
Una vez que tu subgraph esté desplegado y sincronizando (en Hosted Service o Subgraph Studio), usa el Graph Explorer para escribir y probar tus consultas GraphQL. Es la mejor manera de ver qué datos están disponibles y cómo acceder a ellos.
Entiende el Proceso de Indexación y el Estado de Sincronización:
Cuando despliegas un subgraph, Graph Node tarda un tiempo en leer todos los bloques relevantes y procesar los eventos. Monitoriza el 'Sync Status' en la página de tu subgraph en el Graph Explorer. Un subgraph debe estar 'Synced' para que las consultas reflejen el estado más reciente.
Empieza Desplegando al Hosted Service para Desarrollo y Pruebas:
El Hosted Service (hosted-service.thegraph.com) es gratuito y fácil de usar para desarrollo y pruebas. Despliega tu subgraph allí primero. Una vez que esté estable y funcione, considera migrarlo a la Red Descentralizada a través del Subgraph Studio para producción.
Aprende a Definir Entidades y Relaciones Significativas en Tu Esquema GraphQL:
Piensa en la estructura de datos que mejor representa la información que necesitas. Define entidades (ej: `User`, `Token`, `Swap`) y cómo se relacionan. Un buen esquema facilita consultas eficientes para tus dApps.
Revisa la Documentación Oficial para Detalles y Conceptos Avanzados:
La documentación de The Graph (thegraph.com/docs/) es muy completa. Cúbrelo todo, desde conceptos básicos hasta detalles de AssemblyScript para mapeos, forking, rendimiento, etc. Es tu mejor recurso para aprender y resolver dudas.
Si te interesa The Graph, también podrías explorar estas herramientas:
Amplía tus conocimientos con estos enlaces y materiales: