El poder de los subgraphs para acceder a datos blockchain y cómo crear uno con Alchemy

Acceder a los datos y gestionarlos de forma eficiente se ha vuelto fundamental para quienes desarrollan aplicaciones descentralizadas (dApps). A medida que crecen la complejidad y el volumen de los datos on-chain, los métodos tradicionales para obtenerlos se están quedando cortos. Aquí es donde entran en juego los subgraphs, una solución que cambia las reglas del juego para indexar y consultar datos de la blockchain. En este artículo veremos por qué los subgraphs son esenciales y cómo funcionan, y te daremos un tutorial paso a paso para crear un subgraph con Alchemy Subgraph.

Las limitaciones de los endpoints RPC

Antes de entrar en los subgraphs, conviene entender por qué los métodos tradicionales de acceso a los datos de la blockchain, como los endpoints RPC (Remote Procedure Call), se están volviendo insostenibles:

• Problemas de escalabilidad: a medida que una dApp gana popularidad, el número de peticiones a los endpoints RPC se dispara, lo que puede provocar cuellos de botella y tiempos de respuesta lentos.
• Consultas ineficientes: los endpoints RPC no están optimizados para consultas complejas ni para grandes volúmenes de datos, lo que dificulta obtener información concreta de forma eficiente.
• Costos elevados: las llamadas RPC frecuentes pueden salir caras, sobre todo en la mainnet de Ethereum, ya que cada llamada consume recursos y puede generar comisiones.
• Datos históricos limitados: los endpoints RPC suelen dar acceso al estado reciente de la blockchain, lo que complica consultar datos históricos de forma eficiente.
• Estructura de datos poco homogénea: los datos que se obtienen de los endpoints RPC, como los Events, suelen requerir un procesamiento adicional para poder usarse en las aplicaciones, lo que añade complejidad al desarrollo.

Llegan los subgraphs: un cambio radical en el acceso a los datos de Web3

Los subgraphs resuelven estas limitaciones con una forma más eficiente y escalable de indexar y consultar los datos de la blockchain. Por eso están revolucionando el acceso a los datos en el ecosistema Web3:

Cómo funcionan los subgraphs

• Indexación: los subgraphs recorren la blockchain de forma continua en busca de eventos y transacciones relevantes, e indexan los datos en un formato estructurado.
• API GraphQL: los datos indexados se exponen a través de una API GraphQL, de modo que los desarrolladores pueden consultar exactamente los datos que necesitan, ni más ni menos.
• Actualizaciones en tiempo real: a medida que se añaden nuevos bloques a la blockchain, los subgraphs actualizan sus índices automáticamente, así que los datos siempre están al día.
• Personalizables: los desarrolladores pueden definir sus propios esquemas de datos y adaptar el subgraph a las necesidades concretas de su aplicación.

Ventajas de usar subgraphs

• Consultas más rápidas: como los datos están indexados de antemano, los subgraphs devuelven los resultados mucho más rápido que las llamadas RPC tradicionales.
• Menos carga en los nodos: los subgraphs reducen la necesidad de hacer llamadas RPC constantes, lo que disminuye la carga sobre los nodos de la blockchain.
• Rentables: con consultas optimizadas y menos requisitos de infraestructura, los subgraphs pueden reducir de forma significativa los costos operativos de las dApps.
• Mejor experiencia de usuario: obtener los datos más rápido se traduce en dApps más ágiles, lo que mejora la experiencia de usuario en general.
• Consultas complejas, ahora sencillas: GraphQL permite consultas sofisticadas que serían difíciles o imposibles solo con endpoints RPC.

Opciones para crear un subgraph

Los desarrolladores tienen varias opciones para crear y desplegar subgraphs, entre ellas The Graph Protocol (una solución de indexación descentralizada), Alchemy Subgraph (una plataforma gestionada) o soluciones autoalojadas. Este tutorial se centra en Alchemy Subgraph, que ofrece una forma sencilla y rápida de crear y gestionar subgraphs.

Tutorial: crea un subgraph con Alchemy Subgraph

Veamos paso a paso cómo crear un subgraph con Alchemy Subgraph. Vamos a crear un subgraph sencillo que indexa las transferencias de tokens ERC-20 en la mainnet de Ethereum.

Requisitos previos

• Node.js y npm instalados en tu equipo
• Una cuenta de Alchemy (regístrate en https://alchemy.com)
• Conocimientos básicos de GraphQL y Solidity

Paso 1: prepara tu entorno

Primero, instala el CLI de Alchemy Subgraph:

Copiar
npm install -g @graphprotocol/graph-cli

Paso 2: inicializa el proyecto del subgraph

Crea un directorio nuevo para tu proyecto e inicialízalo:

Copiar
mkdir erc20-transfers-subgraph
cd erc20-transfers-subgraph
graph init --product hosted-service

Sigue las indicaciones para configurar el proyecto. Elige un nombre para tu subgraph y selecciona la red (en este caso, la mainnet de Ethereum) y la dirección del contrato que quieres vigilar. Si implementaste un patrón actualizable (upgradeability), asegúrate de indicar la dirección del contrato proxy.

Paso 3: define tu esquema

Edita el archivo schema.graphql para definir las entidades que quieres seguir. Para nuestro subgraph de transferencias ERC-20, usaremos el siguiente esquema:

type Transfer @entity {
  id: ID!
  from: Bytes!
  to: Bytes!
  value: BigInt!
  token: Token!
  timestamp: BigInt!
}

type Token @entity {
  id: ID!
  symbol: String!
  name: String!
  totalSupply: BigInt!
}

Paso 4: actualiza el manifiesto del subgraph

Edita el archivo subgraph.yaml para indicar la dirección del contrato, los eventos que se van a seguir y las funciones de mapping:

specVersion: 0.0.4
schema:
  file: ./schema.graphql
dataSources:
  - kind: ethereum
    name: ERC20
    network: mainnet
    source:
      address: "0x6B175474E89094C44Da98b954EedeAC495271d0F"  # DAI token address
      abi: ERC20
    mapping:
      kind: ethereum/events
      apiVersion: 0.0.6
      language: wasm/assemblyscript
      entities:
        - Transfer
        - Token
      abis:
        - name: ERC20
          file: ./abis/ERC20.json
      eventHandlers:
        - event: Transfer(indexed address,indexed address,uint256)
          handler: handleTransfer
      file: ./src/mapping.ts

Paso 5: implementa las funciones de mapping

Crea el archivo src/mapping.ts e implementa la función handleTransfer:

import { Transfer as TransferEvent } from "../generated/ERC20/ERC20"
import { Transfer, Token } from "../generated/schema"
import { BigInt } from "@graphprotocol/graph-ts"

export function handleTransfer(event: TransferEvent): void {
  let token = Token.load(event.address.toHexString())
  if (token === null) {
    token = new Token(event.address.toHexString())
    token.symbol = "DAI"
    token.name = "Dai Stablecoin"
    token.totalSupply = BigInt.fromI32(0)
    token.save()
  }

  let transfer = new Transfer(event.transaction.hash.toHex() + "-" + event.logIndex.toString())
  transfer.from = event.params.from
  transfer.to = event.params.to
  transfer.value = event.params.value
  transfer.token = token.id
  transfer.timestamp = event.block.timestamp
  transfer.save()
}

Paso 6: genera los tipos

Genera los tipos de TypeScript a partir de tu esquema:

Copiar
graph codegen

Paso 7: compila el subgraph

Compila tu subgraph:

Copiar
graph build

Paso 8: despliega en Alchemy Subgraph

Despliega tu subgraph en Alchemy:

Copiar
graph deploy {YOUR_PROJECT_NAME} \
  --version-label v0.0.1-new-version \
  --node https://subgraphs.alchemy.com/api/subgraphs/deploy \
  --deploy-key {API_KEY} \
  --ipfs https://ipfs.satsuma.xyz

Sustituye {YOUR_PROJECT_NAME} por el nombre de tu proyecto y {API_KEY} por tu clave de API de Alchemy.

Paso 9: consulta tu subgraph

Una vez desplegado, puedes consultar tu subgraph a través del endpoint GraphQL que te proporciona Alchemy. Este es un ejemplo de consulta para obtener las transferencias más recientes:

Copiar
{
  transfers(first: 5, orderBy: timestamp, orderDirection: desc) {
    id
    from
    to
    value
    token {
      symbol
    }
    timestamp
  }
}

Puedes usar el playground que genera Alchemy para construir directamente las consultas GraphQL. Aquí tienes el playground generado para Kleek, nuestra plataforma de eventos basada en blockchain creada durante el hackathon de WalletConnect.

Conclusión

Los subgraphs se han convertido en una herramienta indispensable en el arsenal de cualquier desarrollador Web3, ya que ofrecen una forma más eficiente y escalable de acceder a los datos de la blockchain y consultarlos. Aprovechando el poder de los subgraphs, los desarrolladores pueden crear aplicaciones descentralizadas más rápidas, más ágiles y más rentables.

Alchemy Subgraph ofrece una plataforma fácil de usar para crear y desplegar subgraphs, y hace que aprovechar el potencial de los datos indexados de la blockchain sea más fácil que nunca. A medida que el ecosistema Web3 siga creciendo, los subgraphs tendrán un papel cada vez más decisivo para liberar todo el potencial de la tecnología blockchain.

Con este tutorial has dado tus primeros pasos en el mundo de los subgraphs. Sigue explorando y experimentando con distintos modelos de datos y consultas para descubrir cómo los subgraphs pueden mejorar tus proyectos Web3.