Hello World Smart Contract für Anfänger

Solidity

Hardhat

Alchemy

Smart Contracts

Bereitstellung

Anfänger

elanh

31. März 2021

12 Minuten Lesezeit

Wenn Sie neu in der Blockchain-Entwicklung sind und nicht wissen, wo Sie anfangen sollen, oder wenn Sie einfach nur verstehen möchten, wie man Smart Contracts bereitstellt und mit ihnen interagiert, ist dieser Leitfaden genau das Richtige für Sie. Wir werden die Erstellung und Bereitstellung eines einfachen Smart Contracts im Sepolia-Testnetzwerk durchgehen und dabei eine virtuelle Wallet MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab) und Alchemy (opens in a new tab) verwenden (keine Sorge, falls Sie noch nicht verstehen, was das alles bedeutet, wir werden es erklären).

In Teil 2 dieses Tutorials werden wir durchgehen, wie wir mit unserem Smart Contract interagieren können, sobald er hier bereitgestellt ist, und in Teil 3 werden wir behandeln, wie man ihn auf Etherscan veröffentlicht.

Wenn Sie an irgendeinem Punkt Fragen haben, können Sie sich gerne im Alchemy Discord (opens in a new tab) melden!

Schritt 1: Mit dem Ethereum-Netzwerk verbinden

Es gibt viele Möglichkeiten, Anfragen an die Ethereum-Chain zu stellen. Der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemy, einer Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne unsere eigenen Knoten betreiben zu müssen. Die Plattform verfügt auch über Entwicklertools für Überwachung und Analysen, die wir in diesem Tutorial nutzen werden, um zu verstehen, was bei der Bereitstellung unseres Smart Contracts intern abläuft. Wenn Sie noch kein Alchemy-Konto haben, können Sie sich hier kostenlos anmelden (opens in a new tab).

Schritt 2: Erstellen Sie Ihre App (und Ihren API-Schlüssel)

Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren, indem Sie eine App erstellen. Dies ermöglicht es uns, Anfragen an das Sepolia-Testnetzwerk zu stellen. Wenn Sie nicht mit Testnets vertraut sind, sehen Sie sich diese Seite an.

Navigieren Sie zur Seite „Create new app“ (Neue App erstellen) in Ihrem Alchemy-Dashboard, indem Sie in der Navigationsleiste „Select an app“ (Eine App auswählen) wählen und auf „Create new app“ klicken.

Nennen Sie Ihre App „Hello World“, geben Sie eine kurze Beschreibung an und wählen Sie einen Anwendungsfall, z. B. „Infra & Tooling“. Suchen Sie als Nächstes nach „Ethereum“ und wählen Sie das Netzwerk aus.

Klicken Sie auf „Next“ (Weiter), um fortzufahren, dann auf „Create app“ (App erstellen) und das war's! Ihre App sollte im Dropdown-Menü der Navigationsleiste erscheinen, mit einem API-Schlüssel, den Sie kopieren können.

Schritt 3: Erstellen Sie ein Ethereum-Konto (Adresse)

Wir benötigen ein Ethereum-Konto, um Transaktionen zu senden und zu empfangen. Für dieses Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, die zur Verwaltung Ihrer Ethereum-Konto-Adresse verwendet wird. Mehr zu Transaktionen.

Sie können MetaMask herunterladen und hier (opens in a new tab) kostenlos ein Ethereum-Konto erstellen. Wenn Sie ein Konto erstellen oder bereits eines haben, stellen Sie sicher, dass Sie über das Netzwerk-Dropdown-Menü zum „Sepolia“-Testnetzwerk wechseln (damit wir nicht mit echtem Geld hantieren).

Wenn Sepolia nicht aufgeführt ist, gehen Sie ins Menü, dann auf „Advanced“ (Erweitert) und scrollen Sie nach unten, um „Show test networks“ (Testnetzwerke anzeigen) einzuschalten. Wählen Sie im Netzwerkauswahlmenü die Registerkarte „Custom“ (Benutzerdefiniert), um eine Liste von Testnets zu finden, und wählen Sie „Sepolia“.

Schritt 4: Fügen Sie Ether aus einem Faucet hinzu

Um unseren Smart Contract im Testnetzwerk bereitzustellen, benötigen wir etwas falsches ETH. Um Sepolia-ETH zu erhalten, können Sie zu den Sepolia-Netzwerkdetails gehen, um eine Liste verschiedener Faucets anzuzeigen. Wenn eines nicht funktioniert, versuchen Sie ein anderes, da sie manchmal leerlaufen können. Aufgrund des Netzwerkverkehrs kann es einige Zeit dauern, bis Sie Ihr falsches ETH erhalten. Sie sollten kurz darauf ETH in Ihrem MetaMask-Konto sehen!

Schritt 5: Überprüfen Sie Ihr Guthaben

Um sicherzustellen, dass unser Guthaben vorhanden ist, stellen wir eine eth_getBalance-Anfrage mit dem Composer-Tool von Alchemy (opens in a new tab). Dies gibt die Menge an ETH in unserer Wallet zurück. Nachdem Sie Ihre MetaMask-Konto-Adresse eingegeben und auf „Send Request“ (Anfrage senden) geklickt haben, sollten Sie eine Antwort wie diese sehen:

{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }

HINWEIS: Dieses Ergebnis ist in Wei, nicht in ETH. Wei wird als die kleinste Stückelung von Ether verwendet. Die Umrechnung von Wei in ETH lautet: 1 ETH = 10¹⁸ Wei. Wenn wir also 0x2B5E3AF16B1880000 in eine Dezimalzahl umwandeln, erhalten wir 5*10¹⁸, was 5 ETH entspricht.

Puh! Unser falsches Geld ist komplett da .

Schritt 6: Initialisieren Sie unser Projekt

Zuerst müssen wir einen Ordner für unser Projekt erstellen. Navigieren Sie zu Ihrer Befehlszeile und tippen Sie:

mkdir hello-world
cd hello-world

Da wir uns nun in unserem Projektordner befinden, verwenden wir npm init, um das Projekt zu initialisieren. Wenn Sie npm noch nicht installiert haben, folgen Sie den Installationsanweisungen für Node.js (opens in a new tab) (wir benötigen Node.js und npm für dieses Tutorial).

npm init

Es spielt keine große Rolle, wie Sie die Installationsfragen beantworten. Hier sehen Sie als Referenz, wie wir es gemacht haben:

package name: (hello-world)
version: (1.0.0)
description: hello world smart contract
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/.../.../.../hello-world/package.json:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "hello world smart contract",
  "main": "index.js",
  "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Genehmigen Sie die package.json und wir können loslegen!

Schritt 7: Laden Sie Hardhat (opens in a new tab) herunter

Hardhat ist eine Entwicklungsumgebung zum Kompilieren, Bereitstellen, Testen und Debuggen Ihrer Ethereum-Software. Es hilft Entwicklern beim lokalen Erstellen von Smart Contracts und Dezentralen Anwendungen (Dapps), bevor sie auf der Live-Chain bereitgestellt werden.

Führen Sie in unserem hello-world-Projekt Folgendes aus:

npm install --save-dev hardhat

Auf dieser Seite finden Sie weitere Details zu den Installationsanweisungen (opens in a new tab).

Schritt 8: Erstellen Sie ein Hardhat-Projekt

Führen Sie in unserem Projektordner Folgendes aus:

npx hardhat

Sie sollten dann eine Willkommensnachricht und die Option sehen, auszuwählen, was Sie tun möchten. Wählen Sie „create an empty hardhat.config.js“:

888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.0.11 👷‍?

What do you want to do? …
Create a sample project
❯ Create an empty hardhat.config.js
Quit

Dies generiert eine hardhat.config.js-Datei für uns, in der wir die gesamte Einrichtung für unser Projekt festlegen werden (in Schritt 13).

Schritt 9: Fügen Sie Projektordner hinzu

Um unser Projekt übersichtlich zu halten, erstellen wir zwei neue Ordner. Navigieren Sie in Ihrer Befehlszeile zum Stammverzeichnis Ihres Projekts und tippen Sie:

mkdir contracts
mkdir scripts

In contracts/ werden wir unsere Code-Datei für den Hello World Smart Contract aufbewahren.
In scripts/ werden wir Skripte aufbewahren, um unseren Vertrag bereitzustellen und mit ihm zu interagieren.

Schritt 10: Schreiben Sie unseren Vertrag

Sie fragen sich vielleicht, wann zum Teufel wir endlich Code schreiben werden?? Nun, hier sind wir, bei Schritt 10.

Öffnen Sie das hello-world-Projekt in Ihrem bevorzugten Editor (wir mögen VSCode (opens in a new tab)). Smart Contracts werden in einer Sprache namens Solidity geschrieben, die wir verwenden werden, um unseren HelloWorld.sol Smart Contract zu schreiben.‌

Navigieren Sie zum Ordner „contracts“ und erstellen Sie eine neue Datei namens HelloWorld.sol.
Unten finden Sie einen beispielhaften Hello World Smart Contract von der Ethereum Foundation, den wir für dieses Tutorial verwenden werden. Kopieren Sie den unten stehenden Inhalt und fügen Sie ihn in Ihre HelloWorld.sol-Datei ein. Lesen Sie unbedingt die Kommentare, um zu verstehen, was dieser Vertrag tut:

// Gibt die Version von Solidity unter Verwendung der semantischen Versionierung an.
// Weitere Informationen: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.0;

// Definiert einen Vertrag namens `HelloWorld`.
// Ein Vertrag ist eine Sammlung von Funktionen und Daten (seinem Zustand). Sobald er bereitgestellt ist, befindet sich ein Vertrag an einer bestimmten Adresse auf der Ethereum-Blockchain. Weitere Informationen: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {

   // Deklariert eine Zustandsvariable `message` vom Typ `string`.
   // Zustandsvariablen sind Variablen, deren Werte dauerhaft im Vertragsspeicher gespeichert werden. Das Schlüsselwort `public` macht Variablen von außerhalb eines Vertrags zugänglich und erstellt eine Funktion, die andere Verträge oder Clients aufrufen können, um auf den Wert zuzugreifen.
   string public message;

   // Ähnlich wie in vielen klassenbasierten objektorientierten Sprachen ist ein Konstruktor eine spezielle Funktion, die nur bei der Vertragserstellung ausgeführt wird.
   // Konstruktoren werden verwendet, um die Daten des Vertrags zu initialisieren. Weitere Informationen:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
   constructor(string memory initMessage) {

      // Akzeptiert ein String-Argument `initMessage` und setzt den Wert in die Speichervariable `message` des Vertrags).
      message = initMessage;
   }

   // Eine öffentliche Funktion, die ein String-Argument akzeptiert und die Speichervariable `message` aktualisiert.
   function update(string memory newMessage) public {
      message = newMessage;
   }
}

Dies ist ein super einfacher Smart Contract, der bei der Erstellung eine Nachricht speichert und durch Aufrufen der Funktion update aktualisiert werden kann.

Schritt 11: Verbinden Sie MetaMask & Alchemy mit Ihrem Projekt

Wir haben eine MetaMask-Wallet und ein Alchemy-Konto erstellt sowie unseren Smart Contract geschrieben. Nun ist es an der Zeit, die drei miteinander zu verbinden.

Jede Transaktion, die von Ihrer virtuellen Wallet gesendet wird, erfordert eine Signatur mit Ihrem eindeutigen privaten Schlüssel. Um unserem Programm diese Berechtigung zu erteilen, können wir unseren privaten Schlüssel (und den Alchemy-API-Schlüssel) sicher in einer Umgebungsdatei speichern.

Um mehr über das Senden von Transaktionen zu erfahren, sehen Sie sich dieses Tutorial zum Senden von Transaktionen mit Web3 an.

Installieren Sie zunächst das dotenv-Paket in Ihrem Projektverzeichnis:

npm install dotenv --save

Erstellen Sie dann eine .env-Datei im Stammverzeichnis unseres Projekts und fügen Sie Ihren privaten MetaMask-Schlüssel und die HTTP-Alchemy-API-URL hinzu.

Folgen Sie diesen Anweisungen (opens in a new tab), um Ihren privaten Schlüssel zu exportieren.
Sehen Sie unten, wie Sie die HTTP-Alchemy-API-URL erhalten.

Alchemy-API-URL kopieren

Ihre .env sollte so aussehen:

API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY = "your-metamask-private-key"

Um diese tatsächlich mit unserem Code zu verbinden, werden wir in Schritt 13 in unserer hardhat.config.js-Datei auf diese Variablen verweisen.

Committen Sie .env nicht! Bitte stellen Sie sicher, dass Sie Ihre .env-Datei niemals mit jemandem teilen oder offenlegen, da Sie dadurch Ihre Geheimnisse kompromittieren. Wenn Sie eine Versionskontrolle verwenden, fügen Sie Ihre .env zu einer gitignore-Datei hinzu.

Schritt 12: Installieren Sie Ethers.js

Ethers.js ist eine Bibliothek, die die Interaktion und das Stellen von Anfragen an Ethereum erleichtert, indem sie Standard-JSON-RPC-Methoden in benutzerfreundlichere Methoden verpackt.

Hardhat macht es super einfach, Plugins (opens in a new tab) für zusätzliche Tools und erweiterte Funktionalität zu integrieren. Wir werden das Ethers-Plugin (opens in a new tab) für die Bereitstellung von Verträgen nutzen (Ethers.js (opens in a new tab) verfügt über einige sehr saubere Methoden zur Bereitstellung von Verträgen).

Tippen Sie in Ihrem Projektverzeichnis:

npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"

Im nächsten Schritt werden wir auch Ethers in unserer hardhat.config.js benötigen.

Schritt 13: Aktualisieren Sie hardhat.config.js

Wir haben bisher mehrere Abhängigkeiten und Plugins hinzugefügt. Nun müssen wir hardhat.config.js aktualisieren, damit unser Projekt von all diesen weiß.

Aktualisieren Sie Ihre hardhat.config.js, sodass sie wie folgt aussieht:

require('dotenv').config();

require("@nomiclabs/hardhat-ethers");
const { API_URL, PRIVATE_KEY } = process.env;

/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
   solidity: "0.7.3",
   defaultNetwork: "sepolia",
   networks: {
      hardhat: {},
      sepolia: {
         url: API_URL,
         accounts: [`0x${PRIVATE_KEY}`]
      }
   },
}

Schritt 14: Kompilieren Sie unseren Vertrag

Um sicherzustellen, dass bisher alles funktioniert, lassen Sie uns unseren Vertrag kompilieren. Die Aufgabe compile ist eine der integrierten Hardhat-Aufgaben.

Führen Sie über die Befehlszeile Folgendes aus:

npx hardhat compile

Möglicherweise erhalten Sie eine Warnung bezüglich SPDX license identifier not provided in source file, aber darüber müssen Sie sich keine Sorgen machen – hoffentlich sieht alles andere gut aus! Wenn nicht, können Sie jederzeit im Alchemy Discord (opens in a new tab) schreiben.

Schritt 15: Schreiben Sie unser Bereitstellungsskript

Da unser Vertrag nun geschrieben ist und unsere Konfigurationsdatei einsatzbereit ist, ist es an der Zeit, unser Skript zur Bereitstellung des Vertrags zu schreiben.

Navigieren Sie zum Ordner scripts/ und erstellen Sie eine neue Datei namens deploy.js, der Sie folgenden Inhalt hinzufügen:

async function main() {
   const HelloWorld = await ethers.getContractFactory("HelloWorld");

   // Start deployment, returning a promise that resolves to a contract object
   const hello_world = await HelloWorld.deploy("Hello World!");
   console.log("Contract deployed to address:", hello_world.address);}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

Hardhat leistet hervorragende Arbeit bei der Erklärung, was jede dieser Codezeilen in ihrem Contracts-Tutorial (opens in a new tab) tut. Wir haben ihre Erklärungen hier übernommen.

const HelloWorld = await ethers.getContractFactory("HelloWorld");

Eine ContractFactory in Ethers.js ist eine Abstraktion, die zur Bereitstellung neuer Smart Contracts verwendet wird. Daher ist HelloWorld hier eine Fabrik (Factory) für Instanzen unseres Hello World-Vertrags. Bei Verwendung des hardhat-ethers-Plugins sind ContractFactory- und Contract-Instanzen standardmäßig mit dem ersten Unterzeichner (Signer) verbunden.

const hello_world = await HelloWorld.deploy();

Der Aufruf von deploy() auf einer ContractFactory startet die Bereitstellung und gibt ein Promise zurück, das in einen Contract aufgelöst wird. Dies ist das Objekt, das für jede unserer Smart Contract-Funktionen eine Methode besitzt.

Schritt 16: Stellen Sie unseren Vertrag bereit

Wir sind endlich bereit, unseren Smart Contract bereitzustellen! Navigieren Sie zur Befehlszeile und führen Sie Folgendes aus:

npx hardhat run scripts/deploy.js --network sepolia

Sie sollten dann in etwa Folgendes sehen:

Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

Wenn wir zum Sepolia Etherscan (opens in a new tab) gehen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass er erfolgreich bereitgestellt wurde. Die Transaktion wird in etwa so aussehen:

Die From-Adresse sollte mit Ihrer MetaMask-Konto-Adresse übereinstimmen und bei der Empfängeradresse (To) wird „Contract Creation“ stehen. Wenn wir jedoch in die Transaktion klicken, sehen wir unsere Vertragsadresse im Feld To:

Glückwunsch! Sie haben gerade einen Smart Contract auf der Ethereum-Chain bereitgestellt 🎉

Um zu verstehen, was intern abläuft, navigieren wir zur Registerkarte „Explorer“ in unserem Alchemy-Dashboard (opens in a new tab). Wenn Sie mehrere Alchemy-Apps haben, stellen Sie sicher, dass Sie nach App filtern und „Hello World“ auswählen.

Hier sehen Sie eine Handvoll JSON-RPC-Aufrufe, die Hardhat/Ethers intern für uns getätigt haben, als wir die Funktion .deploy() aufgerufen haben. Zwei wichtige, die hier hervorgehoben werden sollten, sind eth_sendRawTransaction (opens in a new tab), was die Anfrage ist, unseren Vertrag tatsächlich auf die Sepolia-Chain zu schreiben, und eth_getTransactionByHash (opens in a new tab), was eine Anfrage ist, um Informationen über unsere Transaktion anhand des Hashes zu lesen (ein typisches Muster bei Transaktionen). Um mehr über das Senden von Transaktionen zu erfahren, sehen Sie sich dieses Tutorial zum Senden von Transaktionen mit Web3 an.

Das war's für Teil 1 dieses Tutorials. In Teil 2 werden wir tatsächlich mit unserem Smart Contract interagieren, indem wir unsere anfängliche Nachricht aktualisieren, und in Teil 3 werden wir unseren Smart Contract auf Etherscan veröffentlichen, damit jeder weiß, wie man mit ihm interagiert.

Möchten Sie mehr über Alchemy erfahren? Besuchen Sie unsere Website (opens in a new tab). Sie möchten kein Update mehr verpassen? Abonnieren Sie unseren Newsletter hier (opens in a new tab)! Treten Sie unbedingt auch unserem Discord (opens in a new tab) bei..