Docs
⌘ K

18 minutes

AssemblyScript API

Note: If you created a Subgraph prior to graph-cli/graph-ts version 0.22.0, then you’re using an older version of AssemblyScript. It is recommended to review the Migration Guide.

Learn what built-in APIs can be used when writing Subgraph mappings. There are two kinds of APIs available out of the box:

You can also add other libraries as dependencies, as long as they are compatible with AssemblyScript⁠.

Since language mappings are written in AssemblyScript, it is useful to review the language and standard library features from the AssemblyScript wiki⁠.

Reference API

Knihovna @graphprotocol/graph-ts poskytuje následující API:

  • API ethereum pro práci s inteligentními kontrakty Ethereum, událostmi, bloky, transakcemi a hodnotami Ethereum.
  • API store pro načítání a ukládání entit z a do úložiště Graf uzel.
  • A log API to log messages to the Graph Node output and Graph Explorer.
  • API ipfs pro načítání souborů ze IPFS.
  • API json pro rozbor dat JSON.
  • API crypto pro použití kryptografických funkcí.
  • Nízkoúrovňové primitivy pro překlad mezi různými typovými systémy, jako je Ethereum, JSON, GraphQL a AssemblyScript.

Verze

The apiVersion in the Subgraph manifest specifies the mapping API version which is run by Graph Node for a given Subgraph.

VerzePoznámky vydání
0.0.9Adds new host functions eth_get_balance & hasCode
0.0.8Přidá ověření existence polí ve schéma při ukládání entity.
0.0.7Přidání tříd TransactionReceipt a Log do typů Ethereum
Přidání pole receipt do objektu Ethereum událost
0.0.6Přidáno pole nonce do objektu Ethereum Transaction
Přidáno baseFeePerGas do objektu Ethereum bloku
0.0.5AssemblyScript upgraded to version 0.19.10 (this includes breaking changes, please see the Migration Guide)
ethereum.transaction.gasUsed renamed to ethereum.transaction.gasLimit
0.0.4Přidání pole functionSignature do objektu Ethereum SmartContractCall
0.0.3Added from field to the Ethereum Call object
ethereum.call.address renamed to ethereum.call.to
0.0.2Přidání pole input do objektu Ethereum Transackce

Vestavěné typy

Documentation on the base types built into AssemblyScript can be found in the AssemblyScript wiki⁠.

Následující doplňkové typy poskytuje @graphprotocol/graph-ts.

ByteArray

import { ByteArray } from '@graphprotocol/graph-ts'

ByteArray představuje pole u8.

Construction

  • fromI32(x: i32): ByteArray - Rozebrat x na bajty.
  • fromHexString(hex: string): - Vstupní délka musí být sudá. Předpona 0x` je nepovinná.

Type conversions

  • toHexString(): string - Převede na hexadecimální řetězec s předponou 0x.
  • toString(): string - čte bajty jako řetězec UTF-8.
  • toBase58(): string - Zakóduje bajty do řetězce base58.
  • toU32(): u32 - Interpretuje bajty jako little-endian u32. Hodí v případě přetečení.
  • toI32(): i32 - Interpretuje pole bajtů jako little-endian i32. V případě přetečení hází.

Operators

  • equals(y: ByteArray): bool – lze zapsat jakox == y.
  • concat(other: ByteArray) : ByteArray - vrátí nové ByteArray složené z this přímo následované other
  • concatI32(other: i32) : ByteArray - vrátí nové ByteArray složené z this přímo následované bytovou reprezentací other

BigDecimal

import { BigDecimal } from '@graphprotocol/graph-ts'

`BigDecimal se používá k reprezentaci libovolně přesných desetinných míst.

Note: Internally⁠ BigDecimal is stored in IEEE-754 decimal128 floating-point format⁠, which supports 34 decimal digits of significand. This makes BigDecimal unsuitable for representing fixed-point types that can span wider than 34 digits, such as a Solidity ufixed256x18⁠ or equivalent.

Construction

  • constructor(bigInt: BigInt) - vytvoří BigDecimal z BigInt.
  • static fromString(s: string): BigDecimal – parses from a decimal string.

Type conversions

  • toString(): string - vypisuje do desetinného řetězce.

Math

  • plus(y: BigDecimal): BigDecimal – lze zapsat jako x + y.
  • minus(y: BigDecimal): BigDecimal – lze zapsat jako x - y.
  • times(y: BigDecimal): BigDecimal – lze zapsat jako x * y.
  • div(y: BigDecimal): BigDecimal – lze zapsat jakox / y.
  • equals(y: BigDecimal): bool – lze zapsat jakox == y.
  • notEqual(y: BigDecimal): bool – lze zapsat jako`x !=.
  • lt(y: BigDecimal): bool – lze zapsat jakox < y.
  • le(y: BigDecimal): bool – lze zapsat jako x <= y.
  • gt(y: BigDecimal): bool – lze zapsat jako x > y.
  • ge(y: BigDecimal): bool – lze zapsat jako x >= y.
  • neg(): BigDecimal - lze zapsat jako -x.

BigInt

import { BigInt } from '@graphprotocol/graph-ts'

BigInt se používá k reprezentaci velkých celých čísel. Patří sem hodnoty Etherea typu uint32 až uint256 a int64 až int256. Vše pod uint32, jako například uint32, uint24 nebo uint8, je reprezentováno jako i32.

Třída BigInt má následující API:

Construction

  • BigInt.fromI32(x: i32): BigInt - vytvoří BigInt z i32.

  • BigInt.fromString(s: string): BigInt- Zpracuje BigInt z řetězce.

  • BigInt.fromUnsignedBytes(x: Bytes): - Interpretuje bytesjako celé číslo bez znaménka, little-endian. Pokud je váš vstup big-endian, zavolejte nejprve.reverse()`.

  • BigInt.fromSignedBytes(x: Bytes): - Interpretuje bytesjako celé číslo se znaménkem, little-endian. Pokud je váš vstup big-endian, zavolejte nejprve.reverse()`.

    Type conversions

  • x.toHex(): string - změní BigInt na řetězec hexadecimálních znaků.

  • x.toString(): string - změní BigInt na řetězec desetinných čísel.

  • x.toI32(): i32 - vrátí BigInt jako i32; selže, pokud se hodnota nevejde do i32. Je dobré nejprve zkontrolovat x.isI32().

  • x.toBigDecimal(): BigDecimal - převede na desetinné číslo bez zlomkové části.

Math

  • x.plus(y: BigInt): BigInt – lze zapsat jako x + y.
  • x.minus(y: BigInt): BigInt – lze zapsat jako x - y.
  • x.times(y: BigInt): BigInt – lze zapsat jako x * y.
  • x.div(y: BigInt): BigInt – lze zapsat jako x / y.
  • x.mod(y: BigInt): BigInt – lze zapsat jako x % y.
  • x.equals(y: BigInt): bool – lze zapsat jako x == y.
  • x.notEqual(y: BigInt): bool –lze zapsat jako x != y.
  • x.lt(y: BigInt): bool – lze zapsat jako x < y.
  • x.le(y: BigInt): bool – lze zapsat jako x <= y.
  • x.gt(y: BigInt): bool – lze zapsat jako x > y.
  • x.ge(y: BigInt): bool – lze zapsat jako x >= y.
  • x.neg(): BigInt – lze zapsat jako -x.
  • x.divDecimal(y: BigDecimal): BigDecimal – dělí desetinným číslem, čímž získá desetinný výsledek.
  • x.isZero(): bool – Slouží ke kontrole, zda je číslo rovno nule.
  • x.isI32(): bool – Zjistí, zda se číslo vejde do i32.
  • x.abs(): BigInt – absolutní hodnota.
  • x.pow(exp: u8): BigInt – umocňování.
  • bitOr(x: BigInt, y: BigInt): BigInt – lze zapsat jako x | y.
  • bitAnd(x: BigInt, y: BigInt): BigInt – lze zapsat jako x & y.
  • leftShift(x: BigInt, bits: u8): BigInt – lze zapsat jako x << y.
  • rightShift(x: BigInt, bits: u8): BigInt – lze zapsat jako x >> y.

TypedMap

import { TypedMap } from '@graphprotocol/graph-ts'

TypedMap lze použít k ukládání dvojic klíč-hodnota. Viz tento příklad⁠.

Třída TypedMap má následující API:

  • new TypedMap<K, V>() – vytvoří prázdnou mapu s klíči typu K a hodnotami typuV
  • map.set(key: K, value: V): void – nastaví hodnotu key na value
  • map.getEntry(key: K): TypedMapEntry<K, V> | null – vrátí dvojici klíč-hodnota pro key nebo null, pokud key v mapě neexistuje
  • map.get(key: K): V | null – vrací hodnotu pro key nebo null, pokud key v mapě neexistuje
  • map.isSet(key: K): bool – vrací true, pokud klíč v mapě existuje, a false, pokud ne

Bajtů

import { Bytes } from '@graphprotocol/graph-ts'

Bytes se používá k reprezentaci libovolně dlouhých polí bajtů. Patří sem hodnoty Ethereum typu bytes, bytes32 atd.

Třída Bytes rozšiřuje třídu AssemblyScript Uint8Array⁠ a podporuje všechny funkce třídy Uint8Array a navíc následující nové metody:

Construction

  • fromHexString(hex: string) : Bytes - Převede řetězec hex, který se musí skládat ze sudého počtu hexadecimálních číslic, na ByteArray. Řetězec hex může volitelně začínat znakem 0x
  • fromI32(i: i32) : Bytes - Převod i na pole bajtů

Type conversions

  • b.toHex() – vrací hexadecimální řetězec reprezentující bajty v poli
  • b.toString() – převede bajty v poli na řetězec unicode znaků
  • b.toBase58() –změní hodnotu Ethereum Bytes na kódování base58 (používá se pro IPFS hashe)

Operators

  • b.concat(other: Bytes) : Bytes - - “Vrátit nový Bytes skládající se z this, který je přímo následován other.”
  • b.concatI32(other: i32) : ByteArray - vrátí nový Bytes složený z this přímo následovaný bajtovou reprezentací other

Adresa

import { Address } from '@graphprotocol/graph-ts'

Address rozšiřuje Bytes pro reprezentaci hodnot adresa Ethereum.

Přidává následující metodu nad API Bytes:

  • Address.fromString(s: string): Address - vytvoří Address z hexadecimálního řetězce
  • Address.fromBytes(b: Bytes): Adresa - vytvoří Adresu z b, která musí být dlouhá přesně 20 bajtů. Předání hodnoty s menším nebo větším počtem bajtů bude mít za následek chybu

API ukládat

import { store } from '@graphprotocol/graph-ts'

API store umožňuje načítat, ukládat a odebírat entity z a do úložiště Graf uzel.

Entities written to the store map one-to-one to the @entity types defined in the Subgraph’s GraphQL schema. To make working with these entities convenient, the graph codegen command provided by the Graph CLI⁠ generates entity classes, which are subclasses of the built-in Entity type, with property getters and setters for the fields in the schema as well as methods to load and save these entities.

Vytváření entity

Následuje běžný vzor pro vytváření entity z událostí Ethereum.

// Importovat třídu události Transfer vygenerovanou z ERC20 ABIimport { Transfer as TransferEvent } z '../generated/ERC20/ERC20'// Importovat typ entity Transfer vygenerovaný ze schématu GraphQLimport { Transfer } z '../generated/schema'// Obsluha události Transferexport function handleTransfer(event: TransferEvent): void {  // Vytvoří entitu Transfer s použitím hashe transakce jako ID entity  let id = event.transaction.hash  let transfer = new Transfer(id)  // Nastavte vlastnosti entity pomocí parametrů události  transfer.from = event.params.from  transfer.to = event.params.to  transfer.amount = event.params.amount  // Uložení entity do úložiště  transfer.save()}

Pokud se při zpracování řetězce vyskytne událost Transfer, je předána obsluze události handleTransfer pomocí vygenerovaného typu Transfer (zde alias TransferEvent, aby nedošlo ke konfliktu názvů s typem entity). Tento typ umožňuje přístup k datům, jako je nadřazená transakce události a její parametr.

Each entity must have a unique ID to avoid collisions with other entities. It is fairly common for event parameters to include a unique identifier that can be used.

Note: Using the transaction hash as the ID assumes that no other events in the same transaction create entities with this hash as the ID.

Načítání entity z úložiště

Pokud již entita existuje, lze ji z úložiště načíst pomocí následujících příkazů:

let id = event.transaction.hash // nebo jakkoli je ID konstruovánolet transfer = Transfer.load(id)if (transfer == null) {  transfer = new Transfer(id)}// Použijte entitu Transfer jako dříve

As the entity may not exist in the store yet, the load method returns a value of type Transfer | null. It may be necessary to check for the null case before using the value.

Note: Loading entities is only necessary if the changes made in the mapping depend on the previous data of an entity. See the next section for the two ways of updating existing entities.

Vyhledávání entit vytvořených v rámci bloku

Od verzí graph-node v0.31.0, @graphprotocol/graph-ts v0.30.0 a @graphprotocol/graph-cli v0.49.0 je metoda loadInBlock dostupná pro všechny typy entit.

The store API facilitates the retrieval of entities that were created or updated in the current block. A typical situation for this is that one handler creates a transaction from some onchain event, and a later handler wants to access this transaction if it exists.

  • In the case where the transaction does not exist, the Subgraph will have to go to the database simply to find out that the entity does not exist. If the Subgraph author already knows that the entity must have been created in the same block, using loadInBlock avoids this database roundtrip.
  • For some Subgraphs, these missed lookups can contribute significantly to the indexing time.
let id = event.transaction.hash // or however the ID is constructedlet transfer = Transfer.loadInBlock(id)if (transfer == null) {  transfer = new Transfer(id)}// Use the Transfer entity as before

Poznámka: Pokud v daném bloku není vytvořena žádná entita, vrátí loadInBlock hodnotu null, i když v úložišti existuje entita s daným ID.

Vyhledávání odvozených entity

Od verzí graph-node v0.31.0, @graphprotocol/graph-ts v0.31.0 a @graphprotocol/graph-cli v0.51.0 je k dispozici metoda loadRelated.

To umožňuje načítání odvozených polí entityh z obsluhy události. Například při následujícím schématu:

type Token @entity {  id: ID!  holder: Holder!  color: String}type Holder @entity {  id: ID!  tokens: [Token!]! @derivedFrom(field: "holder")}

Následující kód načte entitu Token, ze které byla odvozena entita Holder:

let holder = Holder.load('test-id')// Načtení entit tokenů přidružených k danému držitelilet tokens = holder.tokens.load()

Aktualizace stávajících entity

Existují dva způsoby, jak aktualizovat existující entity:

  1. Načtěte entitu např. pomocí Transfer.load(id), nastavte vlastnosti entity a poté ji .save() uložte zpět do úložiště.
  2. Jednoduše vytvořte entitu např. pomocí new Transfer(id), nastavte vlastnosti entity a poté ji .save() uložte do úložiště. Pokud entita již existuje, změny se do ní sloučí.

Změna vlastností je ve většině případů jednoduchá díky generovaným nastavovačům vlastností:

let transfer = new Transfer(id)transfer.from = ...transfer.to = ...transfer.amount = ...

Vlastnosti lze také zrušit jedním z následujících dvou příkazů:

transfer.from.unset()transfer.from = null

To funguje pouze u nepovinných vlastností, tj. vlastností, které jsou v jazyce GraphQL deklarovány bez znaku !. Dva příklady: owner: Bytes nebo amount: BigInt.

Aktualizace vlastností pole je trochu složitější, protože získání pole z entity vytvoří kopii tohoto pole. To znamená, že vlastnosti pole je třeba po změně pole znovu explicitně nastavit. Následující příklad předpokládá, že entita má čísla: [BigInt!]! pole.

// Tohle nebude fungovatentity.numbers.push(BigInt.fromI32(1))entity.save()// Toto bude fungovatlet numbers = entity.numbersnumbers.push(BigInt.fromI32(1))entity.numbers = numbersentity.save()

Odstranění entit z úložiště

V současné době není možné odstranit entitu prostřednictvím generovaných typů. Místo toho je pro odstranění entity nutné předat název typu entity a ID entity příkazu store.remove:

import { store } from '@graphprotocol/graph-ts'...let id = event.transaction.hashstore.remove('Transfer', id)

Ethereum API

Ethereum API poskytuje přístup k inteligentním smlouvám, veřejným stavovým proměnným, funkcím smluv, událostem, transakcím, blokům a kódování/dekódování dat Etherea.

Podpora typů Ethereum

As with entities, graph codegen generates classes for all smart contracts and events used in a Subgraph. For this, the contract ABIs need to be part of the data source in the Subgraph manifest. Typically, the ABI files are stored in an abis/ folder.

With the generated classes, conversions between Ethereum types and the built-in types take place behind the scenes so that Subgraph authors do not have to worry about them.

The following example illustrates this. Given a Subgraph schema like

type Transfer @entity {  id: Bytes!  from: Bytes!  to: Bytes!  amount: BigInt!}

a podpis události Transfer(address,address,uint256) na platformě Ethereum jsou hodnoty from, to a amount typu adresa, adresa a uint256 převedeny na Address a BigInt, což umožňuje jejich předání do vlastností Bytes! a BigInt! entity Transfer:

let id = event.transaction.hashlet transfer = new Transfer(id)transfer.from = event.params.fromtransfer.to = event.params.totransfer.amount = event.params.amounttransfer.save()

Události a bloková/transakční data

Události Ethereum předávané obsluze událostí, jako je událost Transfer v předchozích příkladech, poskytují přístup nejen k parametrům události, ale také k nadřazené transakci a bloku, jehož jsou součástí. Z instancí event (tyto třídy jsou součástí modulu ethereum v graph-ts) lze získat následující údaje:

class Event {  address: Address  logIndex: BigInt  transactionLogIndex: BigInt  logType: string | null  block: Block  transaction: Transaction  parameters: Array<EventParam>  receipt: TransactionReceipt | null}class Block {  hash: Bytes  parentHash: Bytes  unclesHash: Bytes  author: Address  stateRoot: Bytes  transactionsRoot: Bytes  receiptsRoot: Bytes  number: BigInt  gasUsed: BigInt  gasLimit: BigInt  timestamp: BigInt  difficulty: BigInt  totalDifficulty: BigInt  size: BigInt | null  baseFeePerGas: BigInt | null}class Transaction {  hash: Bytes  index: BigInt  from: Address  to: Address | null  value: BigInt  gasLimit: BigInt  gasPrice: BigInt  input: Bytes  nonce: BigInt}class TransactionReceipt {  transactionHash: Bytes  transactionIndex: BigInt  blockHash: Bytes  blockNumber: BigInt  cumulativeGasUsed: BigInt  gasUsed: BigInt  contractAddress: Address  logs: Array<Log>  status: BigInt  root: Bytes  logsBloom: Bytes}class Log {  address: Address  topics: Array<Bytes>  data: Bytes  blockHash: Bytes  blockNumber: Bytes  transactionHash: Bytes  transactionIndex: BigInt  logIndex: BigInt  transactionLogIndex: BigInt  logType: string  removed: bool | null}

Přístup ke stavu inteligentní smlouvy

The code generated by graph codegen also includes classes for the smart contracts used in the Subgraph. These can be used to access public state variables and call functions of the contract at the current block.

Běžným vzorem je přístup ke smlouvě, ze které událost pochází. Toho lze dosáhnout pomocí následujícího kódu:

// Import vygenerované třídy smlouvy a vygenerované třídy události Transferimport { ERC20Contract, Transfer as TransferEvent } z '../generated/ERC20Contract/ERC20Contract'// Importovat vygenerovanou třídu entitimport { Transfer } z "../generated/schemaexport function handleTransfer(event: TransferEvent) {  // Vázat smlouvu na adresu, která událost vyslala  let contract = ERC20Contract.bind(event.address)  // Přístup ke stavovým proměnným a funkcím jejich voláním  let erc20Symbol = contract.symbol()}

Transfer je zde aliasován na TransferEvent, aby nedošlo ke konfliktu názvů s typ entity

Pokud má smlouva ERC20Contract na platformě Ethereum veřejnou funkci pouze pro čtení s názvem symbol, lze ji volat pomocí .symbol(). Pro veřejné stavové proměnné se automaticky vytvoří metoda se stejným názvem.

Any other contract that is part of the Subgraph can be imported from the generated code and can be bound to a valid address.

Zpracování vrácených volání

If the read-only methods of your contract may revert, then you should handle that by calling the generated contract method prefixed with try_.

  • For example, the Gravity contract exposes the gravatarToOwner method. This code would be able to handle a revert in that method:
let gravity = Gravity.bind(event.address)let callResult = gravity.try_gravatarToOwner(gravatar)if (callResult.reverted) {  log.info('getGravatar reverted', [])} else {  let owner = callResult.value}

Note: A Graph node connected to a Geth or Infura client may not detect all reverts. If you rely on this, we recommend using a Graph Node connected to a Parity client.

Kódování/dekódování ABI

Data lze kódovat a dekódovat podle formátu kódování ABI Ethereum pomocí funkcí encode a decode v modulu ethereum.

import { Address, BigInt, ethereum } from '@graphprotocol/graph-ts'let tupleArray: Array<ethereum.Value> = [  ethereum.Value.fromAddress(Address.fromString('0x0000000000000000000000000000000000000420')),  ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(62)),]let tuple = tupleArray as ethereum.Tuplelet encoded = ethereum.encode(ethereum.Value.fromTuple(tuple))!let decoded = ethereum.decode('(address,uint256)', encoded)

Více informací:

Balance of an Address

The native token balance of an address can be retrieved using the ethereum module. This feature is available from apiVersion: 0.0.9 which is defined subgraph.yaml. The getBalance() retrieves the balance of the specified address as of the end of the block in which the event is triggered.

import { ethereum } from '@graphprotocol/graph-ts'let address = Address.fromString('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')let balance = ethereum.getBalance(address) // returns balance in BigInt

Check if an Address is a Contract or EOA

To check whether an address is a smart contract address or an externally owned address (EOA), use the hasCode() function from the ethereum module which will return boolean. This feature is available from apiVersion: 0.0.9 which is defined subgraph.yaml.

import { ethereum } from '@graphprotocol/graph-ts'let contractAddr = Address.fromString('0x2E645469f354BB4F5c8a05B3b30A929361cf77eC')let isContract = ethereum.hasCode(contractAddr).inner // returns truelet eoa = Address.fromString('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')let isContract = ethereum.hasCode(eoa).inner // returns false

Logging API

import { log } from '@graphprotocol/graph-ts'

The log API allows Subgraphs to log information to the Graph Node standard output as well as Graph Explorer. Messages can be logged using different log levels. A basic format string syntax is provided to compose log messages from argument.

log API obsahuje následující funkce:

  • log.debug(fmt: string, args: Array<string>): void - zaznamená ladicí zprávu.
  • log.info(fmt: string, args: Array<string>): void - zaznamená informační zprávu.
  • log.warning(fmt: string, args: Array<string>): void - zaznamená varování.
  • log.error(fmt: string, args: Array<string>): void - zaznamená chybovou zprávu.
  • log.critical(fmt: string, args: Array<string>): void – logs a critical message and terminates the Subgraph.

log API přebírá formátovací řetězec a pole řetězcových hodnot. Poté nahradí zástupné symboly řetězcovými hodnotami z pole. První zástupný symbol „“ bude nahrazen první hodnotou v poli, druhý zástupný symbol „“ bude nahrazen druhou hodnotou a tak dále.

log.info('Message to be displayed: {}, {}, {}', [value.toString(), anotherValue.toString(), 'already a string'])

Zaznamenávání jedné nebo více hodnot

Zaznamenávání jedné hodnoty

V níže uvedeném příkladu je řetězcová hodnota “A” předána do pole a stane se z ní ['A'], než je zapsána:

let myValue = 'A'export function handleSomeEvent(event: SomeEvent): void {  // Displays : "My value is: A"  log.info('My value is: {}', [myValue])}
Protokolování jedné položky z existujícího pole

V příkladu níže je zaznamenána pouze první hodnota pole argumentů, přestože pole obsahuje tři hodnoty.

let myArray = ['A', 'B', 'C']export function handleSomeEvent(event: SomeEvent): void {  // Displays : "My value is: A"  (Even though three values are passed to `log.info`)  log.info('My value is: {}', myArray)}

Protokolování více záznamů z existujícího pole

Každá položka v poli argumentů vyžaduje vlastní zástupný znak {} v řetězci zprávy protokolu. Níže uvedený příklad obsahuje tři zástupné zna. Z tohoto důvodu jsou zaznamenány všechny tři hodnoty v poli myArray.

let myArray = ['A', 'B', 'C']export function handleSomeEvent(event: SomeEvent): void {  // Displays : "My first value is: A, second value is: B, third value is: C"  log.info('My first value is: {}, second value is: {}, third value is: {}', myArray)}
Protokolování konkrétní položky z existujícího pole

Chcete-li zobrazit konkrétní hodnotu v poli, je třeba zadat indexovanou hodnotu.

export function handleSomeEvent(event: SomeEvent): void {  // Displays : "My third value is C"  log.info('My third value is: {}', [myArray[2]])}
Zaznamenávání informací o událostech

Níže uvedený příklad zaznamenává číslo bloku, hash bloku a hash transakce z události:

import { log } from '@graphprotocol/graph-ts'export function handleSomeEvent(event: SomeEvent): void {  log.debug('Block number: {}, block hash: {}, transaction hash: {}', [    event.block.number.toString(), // "47596000"    event.block.hash.toHexString(), // "0x..."    event.transaction.hash.toHexString(), // "0x..."  ])}

IPFS API

import { ipfs } from '@graphprotocol/graph-ts'

Smart contracts occasionally anchor IPFS files onchain. This allows mappings to obtain the IPFS hashes from the contract and read the corresponding files from IPFS. The file data will be returned as Bytes, which usually requires further processing, e.g. with the json API documented later on this page.

Při zadání hashe nebo cesty IPFS se čtení souboru ze systému IPFS provádí následujícím způsobem:

// Vložte to do obsluhy události v mapovánílet hash = 'QmTkzDwWqPbnAh5YiV5VwcTLnGdwSNsNTn2aDxdXBFca7D'let data = ipfs.cat(hash)// Cesty jako `QmTkzDwWqPbnAh5YiV5VwcTLnGdwSNsNTn2aDxdXBFca7D/Makefile`// které obsahují soubory v adresářích, jsou také podporoványlet path = 'QmTkzDwWqPbnAh5YiV5VwcTLnGdwSNsNTn2aDxdXBFca7D/Makefile'let data = ipfs.cat(cesta)

Poznámka: ipfs.cat není v současné době deterministický. Pokud se soubor nepodaří načíst přes síť IPFS před vypršením požadavku, vrátí se null. Z tohoto důvodu se vždy vyplatí zkontrolovat výsledek na null.

Pomocí nástroje ipfs.map je také možné zpracovávat větší soubory proudovým způsobem. Funkce očekává hash nebo cestu k souboru IPFS, název zpětného volání a příznaky pro úpravu chování:

import { JSONValue, Value } z '@graphprotocol/graph-ts'export function processItem(value: JSONValue, userData: Value): void {  // Podrobnosti o zpracování viz dokumentace k JSONValue  // s hodnotami JSON  let obj = value.toObject()  let id = obj.get('id')  let title = obj.get('title')  if (!id || !title) {    return  }  // Callbacky mohou také vytvářet entity  let newItem = new Item(id)  newItem.title = title.toString()  newitem.parent = userData.toString() // Nastavit rodiče na "parentId"  newitem.save()}// Toto vložte do obsluhy události v mapováníipfs.map('Qm...', 'processItem', Value.fromString('parentId'), ['json'])// Případně použijte `ipfs.mapJSON`ipfs.mapJSON('Qm...', 'processItem', Value.fromString('parentId'))

V současné době je podporován pouze příznak json, který musí být předán souboru ipfs.map. S příznakem json se soubor IPFS musí skládat z řady hodnot JSON, jedna hodnota na řádek. Volání příkazu ipfs.map přečte každý řádek souboru, deserializuje jej do hodnoty JSONValue a pro každou z nich zavolá zpětné volání. Zpětné volání pak může použít operace entit k uložení dat z JSONValue. Změny entit se uloží až po úspěšném ukončení obsluhy, která volala ipfs.map; do té doby se uchovávají v paměti, a velikost souboru, který může ipfs.map zpracovat, je proto omezená.

On success, ipfs.map returns void. If any invocation of the callback causes an error, the handler that invoked ipfs.map is aborted, and the Subgraph is marked as failed.

Crypto API

import { crypto } from '@graphprotocol/graph-ts'

API crypto zpřístupňuje kryptografické funkce pro použití v mapování. Nyní je k dispozici pouze jedna:

  • crypto.keccak256(input: ByteArray): ByteArray

JSON API

import { json, JSONValueKind } from '@graphprotocol/graph-ts'

Data JSON lze analyzovat pomocí API json:

  • json.fromBytes(data: Bytes): JSONValue - analyzuje data JSON z pole Bytes interpretovaného jako platná posloupnost UTF-8
  • json.try_fromBytes(data: Bytes): Výsledek<JSONValue, boolean> - bezpečná verze json.fromBytes, vrací chybovou variantu, pokud se parsování nezdařilo
  • json.fromString(data: string): JSONValue - analyzuje data JSON z platného UTF-8 Řetězce
  • json.try_fromString(data: string): Výsledek<JSONValue, boolean> - bezpečná verze json.fromString, vrací chybovou variantu, pokud se parsování nezdařilo

Třída JSONValue poskytuje způsob, jak vytáhnout hodnoty z libovolného dokumentu JSON. Protože hodnoty JSON mohou být logické, číselné, pole a další, je JSONValue vybavena vlastností kind pro kontrolu typu hodnoty:

let value = json.fromBytes(...)if (value.kind == JSONValueKind.BOOL) {  ...}

Kromě toho existuje metoda pro kontrolu, zda je hodnota null:

  • value.isNull(): boolean

Pokud je typ hodnoty jistý, lze ji převést na vestavěný typ pomocí jedné z následujících metod:

  • value.toBool(): boolean
  • value.toI64(): i64
  • value.toF64(): f64
  • value.toBigInt(): BigInt
  • value.toString(): string
  • value.toArray(): Array<JSONValue> - (a poté převést JSONValue pomocí jedné z 5 výše uvedených metod)

Převody typů Reference

Zdroj(e)DestinaceFunkce převodu
AddressBytesnone
AddressStrings.toHexString()
BigDecimalStrings.toString()
BigIntBigDecimals.toBigDecimal()
BigIntString (hexadecimální)s.toHexString() or s.toHex()
BigIntString (unicode)s.toString()
BigInti32s.toI32()
BooleanBooleannone
Bytes (signed)BigIntBigInt.fromSignedBytes(s)
Bytes (unsigned)BigIntBigInt.fromUnsignedBytes(s)
BytesString (hexadecimální)s.toHexString() or s.toHex()
BytesString (unicode)s.toString()
BytesString (base58)s.toBase58()
Bytesi32s.toI32()
Bytesu32s.toU32()
BytesJSONjson.fromBytes(s)
int8i32none
int32i32none
int32BigIntBigInt.fromI32(s)
uint24i32none
int64 - int256BigIntnone
uint32 - uint256BigIntnone
JSONbooleans.toBool()
JSONi64s.toI64()
JSONu64s.toU64()
JSONf64s.toF64()
JSONBigInts.toBigInt()
JSONstrings.toString()
JSONArrays.toArray()
JSONObjects.toObject()
StringAddressAddress.fromString(s)
BytesAddressAddress.fromBytes(s)
StringBigIntBigInt.fromString(s)
StringBigDecimalBigDecimal.fromString(s)
String (hexadecimální)BytesByteArray.fromHexString(s)
String (UTF-8)BytesByteArray.fromUTF8(s)

Metadata zdroje dat

Adresu smlouvy, síť a kontext zdroje dat, který obslužnou rutinu vyvolal, můžete zkontrolovat prostřednictvím jmenného prostoru dataSource:

  • dataSource.address(): Address
  • dataSource.network(): string
  • dataSource.context(): DataSourceContext

Entity a DataSourceContext

Základní třída Entity a podřízená třída DataSourceContext mají pomocníky pro dynamické nastavování a získávání polí:

  • setString(key: string, value: string): void
  • setI32(key: string, value: i32): void
  • setBigInt(key: string, value: BigInt): void
  • setBytes(key: string, value: Bytes): void
  • setBoolean(key: string, value: bool): void
  • setBigDecimal(key, value: BigDecimal): void
  • getString(key: string): string
  • getI32(key: string): i32
  • getBigInt(key: string): BigInt
  • getBytes(key: string): Bytes
  • getBoolean(key: string): boolean
  • getBigDecimal(key: string): BigDecimal

DataSourceContext v manifestu

The context section within dataSources allows you to define key-value pairs that are accessible within your Subgraph mappings. The available types are Bool, String, Int, Int8, BigDecimal, Bytes, List, and BigInt.

Zde je příklad YAML ilustrující použití různých typů v sekci context:

dataSources:  - kind: ethereum/contract    name: ContractName    network: mainnet    context:      bool_example:        type: Bool        data: true      string_example:        type: String        data: 'hello'      int_example:        type: Int        data: 42      int8_example:        type: Int8        data: 127      big_decimal_example:        type: BigDecimal        data: '10.99'      bytes_example:        type: Bytes        data: '0x68656c6c6f'      list_example:        type: List        data:          - type: Int            data: 1          - type: Int            data: 2          - type: Int            data: 3      big_int_example:        type: BigInt        data: '1000000000000000000000000'
  • Bool: Určuje Boolean hodnotu (true nebo false).
  • String: Určuje hodnotu řetězce.
  • Int: Určuje 32bitové celé číslo.
  • Int8: Určuje 8bitové celé číslo.
  • BigDecimal: Určuje desetinné číslo. Musí být uvedeno v uvozovkách.
  • Bytes: Určuje hexadecimální řetězec.
  • Seznam: Určuje seznam položek. U každé položky je třeba zadat její typ a data.
  • BigInt: Určuje velkou celočíselnou hodnotu. Kvůli velké velikosti musí být uvedena v uvozovkách.

This context is then accessible in your Subgraph mapping files, enabling more dynamic and configurable Subgraphs.