Bygga subgrafer på Arweave

Reading time: 7 min

I den här guiden kommer du att lära dig hur du bygger och distribuerar subgrafer för att indexera Weaver-blockkedjan.

Arweave-protokollet tillåter utvecklare att lagra data permanent och det är den största skillnaden mellan Arweave och IPFS, där IPFS saknar funktionen; beständighet och filer lagrade på Arweave kan inte ändras eller raderas.

Arweave har redan byggt ett flertal bibliotek för att integrera protokollet i ett antal olika programmeringsspråk. För mer information kan du kolla:

• Arwiki
• Arweave Resources

Grafen låter dig bygga anpassade öppna API:er som kallas "Subgraphs". Subgrafer används för att tala om för indexerare (serveroperatörer) vilka data som ska indexeras på en blockchain och sparas på deras servrar så att du när som helst ska kunna fråga dem med GraphQL.

Graph Node Kan nu indexera data på Arweave-protokollet. Den nuvarande integrationen indexerar bara Arweave som en blockchain (block och transaktioner), den indexerar inte de lagrade filerna ännu.

För att kunna bygga och distribuera Arweave Subgraphs behöver du två paket:

1. @graphprotocol/graph-cli ovan version 0.30.2 - Detta är ett kommandoradsverktyg för att bygga och distribuera subgrafer. Klicka här för att ladda ner med npm.
2. @graphprotocol/graph-ts ovan version 0.27.0 - Detta är ett bibliotek med subgrafspecifika typer. Klicka här för att ladda ner med npm.

Det finns tre komponenter i en subgraf:

Definierar datakällorna av intresse och hur de ska behandlas. Arweave är en ny typ av datakälla.

Här definierar du vilken data du vill kunna fråga efter att du har indexerat din subgrafer med GraphQL. Detta liknar faktiskt en modell för ett API, där modellen definierar strukturen för en begäran.

Kraven för Arweave subgrafer täcks av denbefintliga dokumentationen.

Detta är logiken som avgör hur data ska hämtas och lagras när någon interagerar med datakällorna du lyssnar på. Data översätts och lagras utifrån det schema du har listat.

Under subgrafutveckling finns det två nyckelkommandon:

$ graph codegen # generates types from the schema file identified in the manifest
$ graph build # generates Web Assembly from the AssemblyScript files, and prepares all the subgraph files in a /build folder

Subgrafmanifestet subgraph.yaml identifierar datakällorna för subgrafen, utlösare av intresse och funktionerna som ska köras som svar på dessa utlösare. Se nedan för ett exempel på subgraf manifest för en Arweave-subgraf:

specVersion: 0.0.5
description: Arweave Blocks Indexing
schema:
  file: ./schema.graphql # link to the schema file
dataSources:
  - kind: arweave
    name: arweave-blocks
    network: arweave-mainnet # The Graph only supports Arweave Mainnet
    source:
      owner: 'ID-OF-AN-OWNER' # The public key of an Arweave wallet
      startBlock: 0 # set this to 0 to start indexing from chain genesis
    mapping:
      apiVersion: 0.0.5
      language: wasm/assemblyscript
      file: ./src/blocks.ts # link to the file with the Assemblyscript mappings
      entities:
        - Block
        - Transaction
      blockHandlers:
        - handler: handleBlock # the function name in the mapping file
      transactionHandlers:
        - handler: handleTx # the function name in the mapping file

• Arweave subgrafer introducerar en ny typ av datakälla (arweave)
• The network should correspond to a network on the hosting Graph Node. In Subgraph Studio, Arweave's mainnet is arweave-mainnet
• Arweave datakällor introducerar ett valfritt source.owner fält, som är den publika nyckeln till en Arweave plånbok

Arweave datakällor stöder två typer av hanterare:

• blockHandlers - Kör på varje nytt Arweave block. Ingen source.owner krävs.
• transactionHandlers - Kör på varje transaktion där datakällans source.owner är ägare. För närvarande krävs en ägare för transactionHandlers, om användare vill bearbeta alla transaktioner ska de ange "" som source.owner

Schema definition beskriver strukturen för den resulterande subgraf databasen och relationerna mellan enheter. Detta är agnostiskt för den ursprungliga datakällan. Det finns mer information om definitionen av subgraf schema här.

Hanterarna för bearbetning av händelser är skrivna i AssemblyScript.

Arweave indexing introduces Arweave-specific data types to the AssemblyScript API.

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
}

Blockhanterare får ett Block, medan transaktioner får en Transaktion.

Att skriva mappningar av en Arweave subgrafer är mycket lik att skriva mappningar av en Ethereum subgrafer. För mer information, klicka här.

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

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

GraphQL slutpunkten för Arweave subgrafer bestäms av schemadefinitionen, med det befintliga API gränssnittet. Besök GraphQL API dokumentationen för mer information.

Här är ett exempel på subgraf som referens:

• Exempel på subgraf för Arweave

Nej, en subgraf kan bara stödja datakällor från en kedja/nätverk.

För närvarande indexerar The Graph bara Arweave som en blockkedja (dess block och transaktioner).

Detta stöds inte för närvarande.

Source.owner kan vara användarens publika nyckel eller kontoadress.

Data skickas i allmänhet till mappningarna som bytes, som om de lagras direkt returneras i subgrafen i ett hex-format (ex. block- och transaktionshashar). Du kanske vill konvertera till ett base64 eller base64 URL-säkert format i dina mappningar, för att matcha det som visas i blockutforskare som [Arweave Explorer](https: //viewblock.io/arweave/).

Följande bytesToBase64(bytes: Uint8Array, urlSafe: boolean): string hjälpfunktion kan användas och kommer att läggas till i 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;
}