Construction de subgraphs pour Arweave

Reading time: 8 min

Dans ce guide, vous apprendrez comment créer et déployer des subgraphs pour indexer la blockchain Arweave.

Arweave est un protocole qui permet aux développeurs de stocker des données de façon permanente. C'est cette caractéristique qui constitue la principale différence entre Arweave et IPFS. En effet, IPFS n'a pas la caractéristique de permanence, et les fichiers stockés sur Arweave ne peuvent pas être modifiés ou supprimés.

Arweave a déjà construit de nombreuses bibliothèques pour intégrer le protocole dans plusieurs langages de programmation différents. Pour plus d'informations, vous pouvez consulter :

• Arwiki
• Ressources d'Arweave

The Graph vous permet de créer des API ouvertes personnalisées appelées « subgraphes ». Les subgraphes sont utilisés pour indiquer aux indexeurs (gestionnaires de serveur) les données à indexer sur une blockchain et à enregistrer sur leurs serveurs afin que vous puissiez les interroger à tout moment à l'aide de GraphQL.

Graph Node est désormais capable d'indexer les données sur le protocole Arweave. L'intégration actuelle indexe uniquement Arweave en tant que blockchain (blocs et transactions), elle n'indexe pas encore les fichiers stockés.

Pour pouvoir créer et déployer des Arweave Subgraphs, vous avez besoin de deux packages :

1. Les versions supérieures à 0.30.2 du @graphprotocol/graph-cli - Il s'agit d'un outil caractérisé par l'utilisation de lignes de commandes pour construire et déployer des subgraphes. Cliquez ici pour le télécharger en utilisant npm.
2. @graphprotocol/graph-ts version supérieure à 0.27.0 - Il s'agit d'une bibliothèque de types spécifiques aux subgraphs. Cliquez ici pour télécharger en utilisant npm.

Il y a trois composants d'un subgraph :

Définit les sources de données intéressantes et la manière dont elles doivent être traitées. Arweave est un nouveau type de source de données.

Vous définissez ici les données que vous souhaitez pouvoir interroger après avoir indexé votre subgraph à l'aide de GraphQL. Ceci est en fait similaire à un modèle pour une API, où le modèle définit la structure d'un corps de requête.

Les exigences relatives aux subgraphs Arweave sont couvertes par la documentation existante.

Il s'agit de la logique qui détermine comment les données doivent être récupérées et stockées lorsqu'une personne interagit avec les sources de données que vous interrogez. Les données sont traduites et stockées sur la base du schema que vous avez répertorié.

Lors du développement du subgraph, il y a deux commandes clés :

$ graph codegen # génère des types à partir du fichier de schéma identifié dans le manifeste
$ graph build # génère le Web Assembly à partir des fichiers AssemblyScript, et prépare tous les fichiers de subgraphes dans un dossier /build

Le manifeste du subgraph subgraph.yaml identifie les sources de données pour le subgraph, les déclencheurs d'intérêt, et les fonctions qui doivent être exécutées en réponse à ces déclencheurs. Ci-dessous un exemple de manifeste pour un subgraph visant Arweave :

specVersion: 0.0.5
description: Arweave Blocks Indexing
schema:
  file: ./schema.graphql # lien vers le fichier de schéma
dataSources:
  - kind: arweave
    name: arweave-blocks
    network: arweave-mainnet # The Graph ne supporte que le Arweave Mainnet
    source:
      owner: 'ID-OF-AN-OWNER' # La clé publique d'un porte-monnaie Arweave
      startBlock: 0 # mettez cette valeur à 0 pour commencer l'indexation à partir de la genèse de la chaîne.
    mapping:
      apiVersion: 0.0.5
      language: wasm/assemblyscript
      file: ./src/blocks.ts # lien vers le fichier contenant les mappages d'Assemblyscript
      entities:
        - Block
        - Transaction
      blockHandlers:
        - handler: handleBlock # le nom de la fonction dans le fichier de mapping
      transactionHandlers:
        - handler: handleTx # le nom de la fonction dans le fichier de mapping

• Les subgraphs Arweave introduisent un nouveau type de source de données (arweave)
• The network should correspond to a network on the hosting Graph Node. In Subgraph Studio, Arweave's mainnet is arweave-mainnet
• Les sources de données Arweave introduisent un champ source.owner facultatif, qui est la clé publique d'un portefeuille Arweave

Les sources de données Arweave prennent en charge deux types de gestionnaires :

• blockHandlers - Exécuté sur chaque nouveau bloc Arweave. Aucun source.owner n'est requis.
• transactionHandlers : exécuté sur chaque transaction dont le source.owner de la source de données est le propriétaire. Actuellement, un propriétaire est requis pour les transactionHandlers. Si les utilisateurs souhaitent traiter toutes les transactions, ils doivent fournir "" comme source.owner

La définition du schéma décrit la structure de la base de données de subgraphs résultante et les relations entre les entités. Ceci est indépendant de la source de données d’origine. Vous trouverez plus de détails sur la définition du schéma de subgraph ici.

Les gestionnaires pour le traitement des événements sont écrits en AssemblyScript.

L'indexation Arweave introduit des types de données spécifiques à Arweave dans l'API AssemblyScript.

class Block {
  timestamp: u64
  lastRetarget: u64
  height: u64
  indepHash: Bytes
  nonce: Bytes
  previousBlock: Bytes
  diff: Bytes
  hash: Bytes
  txRoot: Bytes
  txs: Bytes[]
  walletList: Bytes
  rewardAddr: Bytes
  tags: Tag[]
  rewardPool: Bytes
  weaveSize: Bytes
  blockSize: Bytes
  cumulativeDiff: Bytes
  hashListMerkle: Bytes
  poa: ProofOfAccess
}

class Transaction {
  format: u32
  id: Bytes
  lastTx: Bytes
  owner: Bytes
  tags: Tag[]
  target: Bytes
  quantity: Bytes
  data: Bytes
  dataSize: Bytes
  dataRoot: Bytes
  signature: Bytes
  reward: Bytes
}

Les gestionnaires de blocs reçoivent un Block, tandis que les transactions reçoivent un Transaction.

L'écriture des mappages d'un subgraph Arweave est très similaire à l'écriture des mappages d'un subgraph Ethereum. Pour plus d'informations, cliquez ici.

Once your subgraph has been created on your Subgraph Studio dashboard, you can deploy by using the graph deploy CLI command.

graph deploy --studio --access-token <your-access-token>

Le endpoint GraphQL pour les subgraphs d'Arweave est déterminé par la définition du schema, avec l'interface API existante. Veuillez consulter la documentation de l'API GraphQL pour plus d'informations.

Voici un exemple de modèle subgraph :

• Exemple de subgraph pour Arweave

Non, un subgraph ne peut supporter que les sources de données d'une seule chaîne/réseau.

Actuellement, The Graph n'indexe Arweave qu'en tant que blockchain (ses blocs et ses transactions).

Cette fonction n'est pas prise en charge actuellement.

La source.owner peut être la clé publique de l'utilisateur ou l'adresse de son compte.

Les données sont généralement transmises dans les mappages sous forme d'octets, qui, s'ils sont stockés directement, sont renvoyés dans le subgraph au format hex (ex. hachages de bloc et de transaction). Vous souhaiterez peut-être convertir vos mappages en un format base64 ou base64 URL sécurisé, afin de correspondre à ce qui est affiché dans les explorateurs de blocs comme [Explorateur Arweave](https : //viewblock.io/arweave/).

La fonction d'assistance bytesToBase64(bytes: Uint8Array, urlSafe: boolean): string suivante peut être utilisée et sera ajoutée à graph-ts :

const base64Alphabet = [
    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"
];

const base64UrlAlphabet = [
    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-", "_"
];

function bytesToBase64(bytes: Uint8Array, urlSafe: boolean): string {
    let alphabet = urlSafe? base64UrlAlphabet : base64Alphabet;

    let result = '', i: i32, l = bytes.length;
    for (i = 2; i < l; i += 3) {
        result += alphabet[bytes[i - 2] >> 2];
        result += alphabet[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
        result += alphabet[((bytes[i - 1] & 0x0F) << 2) | (bytes[i] >> 6)];
        result += alphabet[bytes[i] & 0x3F];
    }
    if (i === l + 1) { // 1 octet yet to write
        result += alphabet[bytes[i - 2] >> 2];
        result += alphabet[(bytes[i - 2] & 0x03) << 4];
        if (!urlSafe) {
            result += "==";
        }
    }
    if (!urlSafe && i === l) { // 2 octets yet to write
        result += alphabet[bytes[i - 2] >> 2];
        result += alphabet[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
        result += alphabet[(bytes[i - 1] & 0x0F) << 2];
        if (!urlSafe) {
            result += "=";
        }
    }
    return result;
}