La puissance des subgraphs pour accéder aux données blockchain, et comment en construire un avec Alchemy

L'accès et la gestion efficaces des données sont devenus déterminants pour qui développe des applications décentralisées (dApps). À mesure que le volume et la complexité des données on-chain augmentent, les méthodes traditionnelles de récupération montrent leurs limites. C'est là qu'interviennent les subgraphs, une solution qui change la donne pour indexer et interroger les données blockchain. Dans cet article, nous verrons pourquoi les subgraphs sont indispensables, comment ils fonctionnent, et nous construirons pas à pas un subgraph avec Alchemy Subgraph.

Les limites des endpoints RPC

Avant de plonger dans les subgraphs, il faut comprendre pourquoi les méthodes traditionnelles d'accès aux données blockchain, comme les endpoints RPC (Remote Procedure Call), deviennent intenables :

• Problèmes de scalabilité : à mesure qu'une dApp gagne en popularité, le nombre de requêtes vers les endpoints RPC explose, avec à la clé des goulots d'étranglement et des temps de réponse dégradés.
• Requêtes inefficaces : les endpoints RPC ne sont pas optimisés pour les requêtes complexes ni les gros volumes, ce qui rend difficile la récupération ciblée d'informations.
• Coûts élevés : les appels RPC fréquents coûtent cher, en particulier sur le mainnet Ethereum, chaque appel consommant des ressources et pouvant être facturé.
• Données historiques limitées : les endpoints RPC donnent généralement accès à l'état récent de la chaîne, ce qui complique l'interrogation efficace des données historiques.
• Structure de données irrégulière : les données récupérées via RPC, comme les Events, demandent souvent un traitement supplémentaire avant d'être exploitables, ce qui alourdit le développement.

Les subgraphs : un tournant pour l'accès aux données Web3

Les subgraphs répondent à ces limites en offrant une manière plus efficace et plus scalable d'indexer et d'interroger les données blockchain. Voici pourquoi ils révolutionnent l'accessibilité des données dans l'écosystème Web3.

Comment fonctionnent les subgraphs

• Indexation : les subgraphs analysent en continu la blockchain à la recherche des événements et transactions pertinents, et indexent les données sous forme structurée.
• API GraphQL : les données indexées sont exposées via une API GraphQL, ce qui permet d'interroger exactement ce dont on a besoin, ni plus ni moins.
• Mises à jour en temps réel : à chaque nouveau bloc, les subgraphs mettent automatiquement leurs index à jour : les données restent toujours à jour.
• Personnalisables : les développeurs définissent leurs propres schémas de données, adaptés aux besoins de leur application.

Les bénéfices des subgraphs

• Des requêtes plus rapides : en préindexant les données, les subgraphs renvoient les résultats bien plus vite que des appels RPC classiques.
• Moins de charge sur les nœuds : les subgraphs réduisent le besoin d'appels RPC constants et allègent la charge des nœuds.
• Un meilleur rapport coût-efficacité : avec des requêtes optimisées et moins d'infrastructure, les subgraphs réduisent sensiblement les coûts d'exploitation d'une dApp.
• Une meilleure expérience utilisateur : une récupération de données plus rapide se traduit par des dApps plus réactives.
• Des requêtes complexes simplifiées : GraphQL autorise des requêtes sophistiquées, difficiles voire impossibles avec les seuls endpoints RPC.

Les options pour construire un subgraph

Plusieurs options existent pour construire et déployer un subgraph : The Graph Protocol (solution d'indexation décentralisée), Alchemy Subgraph (plateforme managée) ou une solution auto-hébergée. Ce tutoriel se concentre sur Alchemy Subgraph, qui propose une approche simple et rapide pour créer et gérer un subgraph.

Tutoriel : construire un subgraph avec Alchemy Subgraph

Suivons le processus de création d'un subgraph avec Alchemy Subgraph. Nous allons créer un subgraph simple qui indexe les transferts de jetons ERC-20 sur le mainnet Ethereum.

Prérequis

• Node.js et npm installés sur votre machine
• Un compte Alchemy (inscription sur https://alchemy.com)
• Des bases en GraphQL et en Solidity

Étape 1 : préparer l'environnement

Commencez par installer le CLI Alchemy Subgraph :

Copy
npm install -g @graphprotocol/graph-cli

Étape 2 : initialiser le projet de subgraph

Créez un dossier pour votre projet et initialisez-le :

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

Suivez les instructions pour configurer le projet. Choisissez un nom pour votre subgraph, sélectionnez le réseau (ici le mainnet Ethereum) et l'adresse du contrat à surveiller. Pensez à indiquer l'adresse du contrat proxy si vous avez mis en place l'upgradeabilité.

Étape 3 : définir votre schéma

Modifiez le fichier schema.graphql pour définir les entités à suivre. Pour notre subgraph de transferts ERC-20, nous utiliserons ce schéma :

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!
}

Étape 4 : mettre à jour le manifeste du subgraph

Modifiez le fichier subgraph.yaml pour indiquer l'adresse du contrat, les événements à suivre et les fonctions 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

Étape 5 : implémenter les fonctions de mapping

Créez le fichier src/mapping.ts et implémentez la fonction 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()
}

Étape 6 : générer les types

Générez les types TypeScript à partir de votre schéma :

Copy
graph codegen

Étape 7 : construire le subgraph

Compilez votre subgraph :

Copy
graph build

Étape 8 : déployer sur Alchemy Subgraph

Déployez votre subgraph chez Alchemy :

Copy
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

Remplacez {YOUR_PROJECT_NAME} par le nom de votre projet et {YOUR_ALCHEMY_API_KEY} par votre clé d'API Alchemy.

Étape 9 : interroger votre subgraph

Une fois déployé, vous pouvez interroger votre subgraph via l'endpoint GraphQL fourni par Alchemy. Voici un exemple de requête pour récupérer les transferts récents :

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

Vous pouvez utiliser le playground généré par Alchemy pour construire directement vos requêtes GraphQL. Voici le playground généré pour Kleek, notre plateforme d'événements on-chain développée pendant le hackathon WalletConnect.

Conclusion

Les subgraphs sont devenus un outil indispensable dans l'arsenal du développeur Web3 : ils offrent une manière plus efficace et plus scalable d'accéder aux données blockchain et de les interroger. En s'appuyant sur eux, on construit des applications décentralisées plus rapides, plus réactives et moins coûteuses.

Alchemy Subgraph propose une plateforme accessible pour construire et déployer des subgraphs, ce qui n'a jamais rendu aussi simple l'exploitation de données blockchain indexées. À mesure que l'écosystème Web3 grandit, les subgraphs joueront un rôle de plus en plus décisif pour révéler tout le potentiel de la blockchain.

En suivant ce tutoriel, vous avez fait vos premiers pas dans l'univers des subgraphs. Continuez à explorer et à expérimenter différents modèles de données et requêtes pour voir tout ce qu'ils peuvent apporter à vos projets Web3.