Desarrollando DApps con The Graph Protocol: Indexando Datos en Ethereum para Consultas Eficientes

¡Bienvenido a este tutorial sobre The Graph Protocol! Si has estado desarrollando DApps en Ethereum, seguramente te habrás encontrado con el desafío de consultar datos de la blockchain de manera eficiente y escalable. Acceder directamente a los datos históricos de un contrato inteligente puede ser lento y costoso. Aquí es donde The Graph brilla, ofreciendo una solución descentralizada para indexar y consultar datos de la blockchain.

En este tutorial, exploraremos The Graph Protocol, aprenderemos cómo funciona, y te guiaré paso a paso en la creación de tu propio subgrafo para indexar eventos y estados de un contrato inteligente de ejemplo. Al final, serás capaz de consultar estos datos indexados usando GraphQL, abriendo un mundo de posibilidades para tus DApps.

📖 ¿Qué es The Graph Protocol? El Google de la Blockchain

Imagina que quieres buscar algo en internet. No vas a cada sitio web individualmente; usas un motor de búsqueda como Google. The Graph hace algo similar para las blockchains. En lugar de que tu DApp tenga que escanear directamente cada bloque de Ethereum para encontrar los datos relevantes, The Graph indexa estos datos por ti y los pone a disposición a través de una API GraphQL de alto rendimiento.

Problema: Consultas de Datos en Ethereum 📉

Las blockchains como Ethereum son excelentes para almacenar transacciones de forma segura e inmutable, pero no están optimizadas para consultas complejas o históricas. Si tu DApp necesita mostrar, por ejemplo, todas las transferencias de un token ERC-20 para un usuario específico, o el historial de precios de un NFT, realizar estas consultas directamente en la blockchain implica:

• Ineficiencia: Recorrer bloques puede ser muy lento.
• Costos: Cada eth_call puede ser costoso en términos de tiempo y recursos de infraestructura.
• Complejidad: Manejar la lógica de reorgs de la blockchain y la sincronización es complicado.

Solución: Indexación Descentralizada con The Graph ✨

The Graph resuelve esto permitiendo a los desarrolladores definir subgrafos. Un subgrafo es una especificación de cómo indexar y organizar los datos de un contrato inteligente. Una vez que un subgrafo se implementa y despliega, The Graph Network lo procesa, indexando los datos relevantes y haciéndolos accesibles a través de una API GraphQL. ¡Es como crear tu propia base de datos optimizada para tu DApp, pero descentralizada!

🛠️ Componentes Clave de The Graph

Para entender cómo funciona The Graph, es útil conocer sus componentes principales:

• Subgrafo (Subgraph): La definición de los datos que quieres indexar. Incluye un esquema GraphQL, un manifiesto (YAML) y mapeos (AssemblyScript).
• Esquema GraphQL (Schema.graphql): Define la estructura de los datos que serán consultados. Es tu "modelo de datos".
• Manifiesto (Subgraph.yaml): Archivo de configuración que especifica qué contratos inteligentes observar, qué eventos escuchar y dónde se encuentran los mappings.
• Mapeos (Mappings - AssemblyScript): Pequeños programas (escritos en una variante de TypeScript) que se ejecutan cada vez que ocurre un evento relevante en la blockchain. Estos mapeos transforman los datos del evento en entidades definidas en tu esquema GraphQL y los almacenan para su consulta.
• Graph Node: El software que ejecuta los subgrafos, indexa los datos y sirve la API GraphQL.
• Graph Explorer/Hosted Service: La interfaz para buscar, desplegar y consultar subgrafos. Para este tutorial usaremos el servicio alojado de The Graph.
• Graph Network (Decentralized): La versión descentralizada de The Graph, donde Indexers, Curators y Delegators interactúan para asegurar la indexación de datos de manera fiable y económica.

🚀 Configurando tu Entorno de Desarrollo

Antes de empezar a escribir código, necesitamos configurar algunas herramientas.

Prerrequisitos:

• Node.js y npm/yarn: Asegúrate de tenerlos instalados (versión 12 o superior).
• Un contrato inteligente en Ethereum: Usaremos un contrato simple desplegado en una red de prueba (como Sepolia).
• Cuenta en The Graph Hosted Service: Para desplegar nuestro subgrafo. Visita https://thegraph.com/hosted-service/ y crea una cuenta.

Instalación de The Graph CLI

La graph-cli es la herramienta de línea de comandos que te permitirá crear, construir y desplegar subgrafos.

npm install -g @graphprotocol/graph-cli
# O si usas yarn
yarn global add @graphprotocol/graph-cli

Verifica la instalación:

graph --version

Deberías ver la versión de la CLI instalada.

🎯 Creando un Contrato Inteligente de Ejemplo

Para este tutorial, usaremos un contrato Solidity muy simple que emite eventos. Imagina un contrato de registro de Mensajes.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MessageBoard {
    struct Message {
        address sender;
        string content;
        uint256 timestamp;
        uint256 id;
    }

    Message[] public messages;
    uint256 private nextMessageId;

    event MessageSent(uint256 id, address indexed sender, string content, uint256 timestamp);

    constructor() {
        nextMessageId = 0;
    }

    function sendMessage(string calldata _content) public {
        uint256 currentId = nextMessageId;
        messages.push(Message(msg.sender, _content, block.timestamp, currentId));
        emit MessageSent(currentId, msg.sender, _content, block.timestamp);
        nextMessageId++;
    }

    function getMessage(uint256 _id) public view returns (address sender, string memory content, uint256 timestamp) {
        require(_id < messages.length, "Message does not exist");
        Message storage message = messages[_id];
        return (message.sender, message.content, message.timestamp);
    }

    function getTotalMessages() public view returns (uint256) {
        return messages.length;
    }
}

Despliegue del Contrato

Despliega este contrato en una red de prueba como Sepolia. Puedes usar Remix, Hardhat o Foundry para esto. Asegúrate de guardar la dirección del contrato y el ABI (Application Binary Interface), ya que los necesitaremos para The Graph.

Una vez desplegado, interactúa con él un par de veces. Envía algunos mensajes para generar eventos que The Graph pueda indexar.

Por ejemplo, en Remix:

1. Compila el contrato MessageBoard.sol.
2. En la pestaña "Deploy & Run Transactions", selecciona el entorno "Injected Provider - Metamask" (conectado a Sepolia).
3. Despliega el contrato.
4. Copia la dirección del contrato.
5. Usa la función sendMessage varias veces con distintos contenidos (ej. "Hola Mundo", "Segundo Mensaje", "Mensaje de Prueba"). Esto generará eventos MessageSent.

🚀 Creando tu Primer Subgrafo

Ahora que tenemos nuestro contrato desplegado y con algunos eventos, vamos a crear el subgrafo.

1. Inicializar el Subgrafo

Navega a un directorio vacío en tu terminal y usa el comando graph init:

graph init --product hosted-service <USERNAME>/message-board-subgraph

Reemplaza <USERNAME> con tu nombre de usuario de The Graph Hosted Service. La CLI te pedirá información:

• Protocol: ethereum
• Subgraph slug: message-board-subgraph (o el que quieras)
• Directory to create the subgraph in: message-board-subgraph (recomendado)
• Ethereum network: sepolia (o la red donde desplegaste el contrato)
• Contract address: Pega la dirección de tu contrato MessageBoard desplegado.
• Contract ABI file: Pega la ruta a tu archivo ABI. Si usas Remix, puedes descargarlo de la pestaña "Compiler" o copiarlo de la metadata.json.

? Protocol (Ethereum, NEAR, etc.) ethereum
? Subgraph slug (e.g. your-name/your-product) tu_usuario/message-board-subgraph
? Directory to create the subgraph in message-board-subgraph
? Ethereum network (e.g. mainnet, goerli) sepolia
? Contract address 0x... (pega aquí la dirección de tu contrato)
? ABI file path (e.g. path/to/Contract.json) path/to/MessageBoard.json (o .abi)
? Add another contract? No
? Index contract events as entities? Yes

Esto generará una estructura de archivos básica:

message-board-subgraph/
├── .gitignore
├── package.json
├── subgraph.yaml
├── schema.graphql
└── src/
    └── message-board.ts

2. Definiendo el Esquema GraphQL (schema.graphql)

El archivo schema.graphql define cómo se verán los datos cuando los consultes. Cada type en tu esquema que tenga la directiva @entity se mapeará a una tabla en la base de datos de The Graph.

Por defecto, graph init habrá generado un ExampleEntity. Borra eso y define tu propia entidad Message.

# schema.graphql

type Message @entity(immutable: true) {
  id: Bytes! # El ID de la entidad, generalmente el hash de la transacción + log index
  messageId: BigInt! # El ID del mensaje del contrato
  sender: Bytes! # La dirección del remitente
  content: String! # El contenido del mensaje
  timestamp: BigInt! # La marca de tiempo de la transacción
  transactionHash: Bytes! # Hash de la transacción
}

Después de modificar el esquema, debes generar los tipos de TypeScript correspondientes:

cd message-board-subgraph
graph codegen

Esto actualizará el archivo src/schema.ts con los tipos de datos que usaremos en los mapeos.

3. Configurando el Manifiesto del Subgrafo (subgraph.yaml)

Este archivo es el corazón de tu subgrafo. Le dice a The Graph qué contrato observar, qué eventos escuchar y qué funciones de mapeo ejecutar.

graph init ya habrá generado la mayor parte. Revisemos las partes clave:

# subgraph.yaml

specVersion: 0.0.5
schema:
  file: ./schema.graphql
dataSources:
  - kind: ethereum/contract
    name: MessageBoard
    network: sepolia # Asegúrate que sea la red correcta
    source:
      address: