Chainlink Oracle Node auf Moonbeam. Inbetriebnahme.

Einführung

Als offenes, erlaubnisloses (permissionless) Netzwerk kann jeder ein Oracle betreiben, das Daten für Smart Contracts bereitstellt, die auf Moonbeam laufen.

Dieser Artikel bietet einen Überblick über die Einrichtung eines Chainlink Oracle auf Moonbase Alpha.

Basisanfragemodell (Basic Request Model)

Bevor wir uns mit den ersten Schritten befassen, ist es wichtig, die Grundlagen des "basic request model" zu verstehen.

Ein Oracle Node hat eine Reihe von job IDs, von denen jede einer Aufgabe entspricht, die von einem Benutzer angefordert werden kann, z. B. einen Preisfeed abrufen. Dazu muss der Benutzer eine Anfrage über einen Vertrag (contract) senden, wir nennen ihn den Kundenvertrag (Client contract) und geben die folgenden Informationen ein:

• Oracle-Adresse (oracle address): Adresse des vom Oracle Node bereitgestellten Vertrags (contract)
• Job ID: auszuführende Aufgabe
• Zahlung (payment): Zahlung in LINK-Token, die das Oracle für die Erfüllung der Anfrage erhält

Diese Anfrage sendet tatsächlich einen transferAndCall an den LINK-Token-Vertrag (LINK token contract), der die Zahlung abwickelt und die Anfrage an den Oracle-Vertrag (Oracle contract) weiterleitet. Dabei wird mit der Anfrage ein Ereignis (Event) ausgesendet, das vom Oracle Node abgeholt wird. Als nächstes ruft der Node die erforderlichen Daten ab und führt die Funktion fulfilOracleRequest aus, die einen Rückruf ausführt, der die angeforderten Informationen im Client-Vertrag (Client contract) speichert. Das folgende Diagramm erläutert diesen Arbeitsablauf:

Fortgeschrittene Benutzer

Wenn Sie mit dem Betreiben von Chainlink Oracle-Node vertraut sind, können Sie mit diesen Informationen im Moonbase Alpha TestNet beginnen:

• Chainlink-Dokumentation
• Moonbase Alpha WSS EndPoint: wss://wss.testnet.moonbeam.network
• Moonbase Alpha ChainId: 1287
• LINK Token auf Moonbase Alpha:0xa36085F69e2889c224210F603D836748e7dC0088
• Hol dir Moonbase Alpha-Token von unserem Faucet

Einstieg

Diese Anleitung führt Sie durch den Prozess zum Einrichten des Oracle-Node:

• Einen Chainlink-Node einrichten, der mit Moonbase Alpha verbunden ist
• Bereitstellen eines Oracle-Vertrags (Oracle contract)
• Einen job auf dem Chainlink-Node erstellen
• Node und Oracle binden
• Client contract testen

Die Grundvoraussetzungen sind:

• Docker zum Ausführen von Postgres DB- und ChainLink-Nodecontainern. Weitere Informationen zur Installation von Docker finden Sie auf dieser Seite
• Ein Konto (account) mit Coins. Sie können ein mit Metamask erstellen, die über unseren Faucet finanziert werden kann
• Zugriff auf die Remix IDE, falls Sie sie zum Bereitstellen des Oracle contract verwenden möchten. Mehr Informationen zu Remix auf Moonbeam finden Sie hier

Nodeeinrichtung

Zuerst erstellen wir ein neues Verzeichnis, um alle erforderlichen Dateien abzulegen. Beispielsweise:

mkdir -p ~/.chainlink-moonbeam //
cd ~/.chainlink-moonbeam

Als Nächstes erstellen wir eine Postgres DB mit Docker. Führen Sie dazu den folgenden Befehl aus (MacOs-Benutzer können --network host \ with -p 5432:5432):

docker run -d --name chainlink_postgres_db \
    --volume chainlink_postgres_data:/var/lib/postgresql/data \
    -e 'POSTGRES_PASSWORD={YOU_PASSWORD_HERE}' \
    -e 'POSTGRES_USER=chainlink' \
    --network host \
    -t postgres:11

Stellen Sie sicher, dass Sie {YOU_PASSWORD_HERE}durch ein Passwort ersetzen.

Docker fährt fort die erforderlichen Images herunterzuladen, wenn sie nicht verfügbar sind. Nun müssen wir im neu erstellten Verzeichnis eine Umgebungsdatei für Chainlink erstellen. Diese Datei wird bei der Erstellung des Chainlink-Containers gelesen. MacOs-Benutzer können localhost durch host.docker.internal ersetzen.

echo "ROOT=/chainlink
LOG_LEVEL=debug
ETH_CHAIN_ID=1287
MIN_OUTGOING_CONFIRMATIONS=2
LINK_CONTRACT_ADDRESS={LINK TOKEN CONTRACT ADDRESS}
CHAINLINK_TLS_PORT=0
SECURE_COOKIES=false
GAS_UPDATER_ENABLED=false
ALLOW_ORIGINS=*
ETH_URL=wss://wss.testnet.moonbeam.network
DATABASE_URL=postgresql://chainlink:{YOUR_PASSWORD_HERE}@localhost:5432/chainlink?sslmode=disable
MINIMUM_CONTRACT_PAYMENT=0" > ~/.chainlink-moonbeam/.env

Hier müssen wir neben dem Passwort ({YOUR_PASSWORD_HERE}) den Link token contract ({LINK TOKEN CONTRACT ADDRESS}) angeben. Nachdem wir die Umgebungsdatei erstellt haben, benötigen wir auch eine .api-Datei, die den Benutzer und das Kennwort speichert, die für den Zugriff auf die API des Nodes, die Benutzeroberfläche (UI) des Nodes und die Chainlink-Befehlszeile (command line) verwendet werden.

echo "{AN_EMAIL_ADDRESS}" >  ~/.chainlink-moonbeam/.api
echo "{ANOTHER_PASSWORD}"   >> ~/.chainlink-moonbeam/.api

Legen Sie sowohl eine E-Mail-Adresse als auch ein anderes Passwort fest. Schließlich benötigen wir eine weitere Datei, die das Wallet-Passwort für die Adresse des Nodes speichert:

echo "{THIRD_PASSWORD}" > ~/.chainlink-moonbeam/.password

Nachdem wir nun alle notwendigen Dateien erstellt haben, können wir die Container mit dem folgenden Befehl starten (MacOs-Benutzer können --network host \ durch -p 6688:6688 ersetzen):

docker run -d --name chainlink_oracle_node \
    --volume $(pwd):/chainlink \
    --env-file=.env \
    --network host \
    -t smartcontract/chainlink:0.9.2 \
        local n \
        -p /chainlink/.password \
        -a /chainlink/.api

Um zu überprüfen, ob alles läuft und die Logs voranschreiten, verwenden Sie:

docker ps #Containers Running
docker logs --tail 50 {container_id} #Logs progressing

Vertragseinrichtung (Contract Setup)

Wenn der Oracle-Node läuft, konfigurieren wir smart contract.

Zuerst müssen wir die Adresse abrufen, die der Oracle-Node verwendet, um Transaktionen zu senden und Daten on-chain zu schreiben. Um die Adresse abzurufen, melden Sie sich mit den Anmeldeinformationen aus der .api Datei bei der Benutzeroberfläche des ChainLink-Nodes(unter http://localhost:6688/) an.

Gehen Sie zur 'Configuration Page' und kopieren Sie die Nodeadresse (node address). Verwenden Sie den Moonbeam Faucet, um es zu finanzieren.

Als nächstes müssen wir den Oracle-Vertrag (Oracle contract) bereitstellen (deploy), die Middleware zwischen der chain und dem Node. Der Vertrag (contract) gibt ein Ereignis (event) mit allen notwendigen Informationen aus, das vom Oracle-Node gelesen wird. Dann erfüllt der Nodedie Anfrage und schreibt die angeforderten Daten in den Vertrag (contract) des Anrufers (caller's).

Den Quellcode des Oracle-Vertrags (Oracle contract) finden Sie hier im offiziellen GitHub-Repository von Chainlink. In diesem Beispiel verwenden wir Remix, um mit Moonbase Alpha zu interagieren und den Vertrag bereitzustellen (deploy the contract). In Remix können wir den folgenden Code kopieren:

pragma solidity ^0.6.6;

import "https://github.com/smartcontractkit/chainlink/evm-contracts/src/v0.6/Oracle.sol";

Gehen Sie nach der Kompillierungung des Vertrags zum Tab "Deploy and Run Transactions", geben Sie die Link-Token-Adresse ein und stellen Sie den Vertrag bereit (deploy the contract). Kopieren Sie nach der Bereitstellung die Adresse des Vertrags (address of the contract).

Schließlich müssen wir den Oracle-Node und den Oracle smart contract verbinden. Ein Node kann die Anfragen annehmen, die an einen bestimmten Oracle-Vertrag (Oracle contract) gesendet werden, aber nur autorisierte (alias gebundene /aka. bonded) Nodes können die Anfrage mit einem Ergebnis erfüllen.

Um diese Berechtigung zu setzen, können wir die FunktiontFulfillmentPermission() aus dem Oracle-Vertrag verwenden. Dies benötigt zwei Parameter:

• Die Adresse des Nodes, den wir an den Vertrag (contract) binden möchten (was wir im vorherigen Schritt getan haben)
• Ein boolescher Wert, der den Bondstatus angibt. In diesem Fall setzen wir es auf true

Dazu können wir die auf Remix bereitgestellte Instanz des Vertrags verwenden und überprüfen, ob der Oracle-Node mit der Funktion getAuthorizationStatus() autorisiert ist, indem wir die Oracle-Nodeadresse übergeben.

Job auf dem Oracle-Node erstellen

Der letzte Schritt, um ein vollständig konfiguriertes Chainlink-Oracle zu haben, besteht darin, einen Job zu erstellen. Offizielle Dokumentation von Chainlink:

Eine Jobspezifikation (specs) enthält die sequentiellen Aufgaben, die der Node ausführen muss, um ein Endergebnis zu erzielen. Eine Spezifikation enthält mindestens einen Initiator und eine Aufgabe, die im Folgenden ausführlich besprochen werden. Spezifikationen werden mit Standard JSON definiert, sodass sie für Menschen lesbar sind und vom Chainlink-Noden leicht geparst werden können

Wenn wir ein Oracle als API service betrachten, wäre ein Job hier eine der Funktionen, die wir aufrufen können und die ein Ergebnis zurückgeben. Um unseren ersten Job zu erstellen, gehen Sie zu den Jobs sections Ihres Nodes und klicken Sie auf "Neuer Job".

Fügen Sie als Nächstes den folgenden JSON-Code ein. Dadurch wird ein Job erstellt, der den aktuellen ETH-Preis in USD anfordert. Stellen Sie sicher, dass Sie Ihre Oracle-Vertragsadresse (YOUR_ORACLE_CONTRACT_ADDRESS) eingeben.

{
  "initiators": [
    {
      "type": "runlog",
      "params": { "address": "YOUR_ORACLE_CONTRACT_ADDRESS" }
    }
  ],
  "tasks": [
    {
      "type": "httpget",
      "params": { "get": "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD" }
    },
    {
      "type": "jsonparse",
      "params": { "path": [ "USD" ] }
    },
    {
      "type": "multiply",
      "params": { "times": 100 }
    },
    { "type": "ethuint256" },
    { "type": "ethtx" }
  ]
}

Sie haben einen Chainlink Oracle Node vollständig eingerichtet, der auf Moonbase Alpha läuft.

Oracle testen

Um zu überprüfen, ob Oracle aktiv ist und Anfragen beantwortet, folgen Sie unserem Oracle-Tutorial. Die Hauptidee besteht darin, einen Kundenvertrag (client contract) bereitzustellen, der Anfragen an das Oracle stellt, und das Oracle schreibt die angeforderten Daten in den Speicher des Vertrags (contract's storage).

Original (engl.)