6 Minuten Lesezeit

Übersicht

Ethereum-Entwicklungsumgebungen wie Hardhat erleichtern die Arbeit mit Smart Contracts und Ethereum-Knoten. Sie bieten eine Reihe von Tools, mit denen sich Smart Contracts nahtlos erstellen, testen und bereitstellen lassen. In dieser Anleitung erstellen wir einen „Hello World“-Smart Contract und stellen ihn mithilfe von Hardhat und Quicknode im Sepolia-Testnetz bereit.

Voraussetzungen

• Ein Quicknode-Konto ( hier kostenlos erstellen)
• Eine EVM-kompatible Wallet (z. B. MetaMask)
• Node.js ist installiert
• Hardhat ist installiert (wir werden darauf im Leitfaden ebenfalls eingehen)
• Befehlszeile/Terminalfenster
• Code- oder Texteditor (z. B. VSCode)
• ETH im Sepolia-Testnetz (über den Quicknode Multi-Chain-Faucet können Sie kostenlos welche erhalten)

Was ist Hardhat?

Hardhat ist eine Entwicklungsumgebung, die Entwicklern dabei hilft, ihre Ethereum-Anwendungen zu kompilieren, bereitzustellen, zu testen und zu debuggen. Sie verfügt über eine der übersichtlichsten und ausführlichsten Dokumentationen. Hardhat bietet zudem eine console.log()-Funktionalität, ähnlich wie in JavaScript, für Debugging-Zwecke. Darüber hinaus verfügt Hardhat über zahlreiche Plugins, die den Funktionsumfang noch weiter erweitern.

Hardhat und andere Abhängigkeiten installieren

Wir werden Hardhat mit npm installieren, das im Lieferumfang von Node.js enthalten ist. 

Erstellen Sie zunächst ein neues Projektverzeichnis und wechseln Sie dorthin. Sie können hier gerne Ihre eigenen Namen verwenden:

mkdir HardhatTutorial
cd HardhatTutorial

Öffnen Sie das Terminal/die Eingabeaufforderung in Ihrem Projektverzeichnis und geben Sie die folgenden Befehle ein.

npm init --y
npm install --save-dev hardhat

Nachdem wir Hardhat nun installiert haben, wollen wir ein neues Hardhat-Projekt starten. Dazu verwenden wir npx. Npx hilft bei der Ausführung von Node.js-Programmen. 

npx hardhat init

Es erscheint die CLI-Oberfläche von Hardhat. Wählen Sie „Create an empty hardhat.config.js“ aus und drücken Sie die Eingabetaste.

Nun installieren wir die weiteren Abhängigkeiten, die für die Arbeit mit Hardhat erforderlich sind.

npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

Wir benötigen diese Abhängigkeiten, um automatisierte Tests für Verträge zu schreiben.

Das häufigste Problem bei der Installation von Paketen mit npm kann ein interner Fehler bei `node-gyp` sein. Die Installationsanleitung für node-gyp finden Sie hier.

Hinweis: Falls das „node-gyp“-Problem auftritt, muss Ihre Python-Version mit einer der in der obigen Anleitung aufgeführten kompatiblen Versionen übereinstimmen. 

Ein weiteres häufiges Problem ist ein veralteter Cache. Leeren Sie Ihren npm-Cache, indem Sie einfach den folgenden Befehl in Ihr Terminal eingeben:

npm cache clean

Nun richten wir einen privaten Schlüssel für unsere Wallet, etwas Test-ETH für die Gasgebühren und einen Ethereum-Knoten ein; all das benötigen wir, um unseren Smart Contract zu deployen.

Erstellen/Abrufen des privaten Schlüssels

Wir benötigen eine Ethereum-Wallet, um die Bereitstellung unseres Smart Contracts zu bezahlen.

Sobald Ihre Wallet erstellt ist und Sie den privaten Schlüssel abgerufen haben, fügen wir ihn im nächsten Abschnitt zur Hardhat-Konfigurationsdatei (z. B. hardhat.config.js) hinzu.

Sie können den Anleitungen von Quicknode folgen, um einen privaten Schlüssel und eine Ethereum-Adresse in JavaScript, Ruby, Python, Go und PHP zu generieren.

Um den privaten Schlüssel aus Ihrer MetaMask-Wallet abzurufen, befolgen Sie bitte diese Anweisungen:

• Klicken Sie in Ihrem Browser auf das MetaMask-Symbol, einen stilisierten Fuchskopf. Falls es nicht zu sehen ist, überprüfen Sie die Seite „Erweiterungen“ Ihres Browsers.
• Klicken Sie auf das Symbol ⋮ und anschließend auf „Kontodaten“.
• Klicken Sie anschließend auf „Privaten Schlüssel anzeigen “ und befolgen Sie die Anweisungen.

Kopieren Sie den privaten Schlüssel und speichern Sie ihn; wir werden ihn in den folgenden Schritten benötigen.

Es wird empfohlen, sensible Informationen wie private Schlüssel in einer .env-Datei zu speichern und diese über Umgebungsvariablen in die Konfigurationsdatei zu übernehmen oder eine neue, sekundäre MetaMask-Wallet ausschließlich für Entwicklungszwecke anzulegen.

Testnet-ETH beziehen

Wir werden unseren Vertrag im Sepolia-Testnetz bereitstellen. Dazu benötigen wir zunächst etwas Test-ETH in unserer MetaMask-Wallet, wie wir im letzten Schritt gesehen haben.

Rufen Sie den Quicknode Multi-Chain Faucet auf und verbinden Sie Ihre Wallet oder fügen Sie Ihre Wallet-Adresse ein. Sie müssen die Ethereum-Chain und das Sepolia-Netzwerk auswählen und anschließend eine Auszahlung beantragen.

Hinweis: Sie benötigen ein Guthaben von mindestens 0,001 ETH im Ethereum-Mainnet, um den Faucet nutzen zu können.

Einrichten eines Quicknode-Ethereum-Endpunkts

Um unseren Vertrag auf der Ethereum-Sepolia-Blockchain zu deployen, benötigen wir Zugriff auf einen Ethereum-Sepolia-Knoten. Dazu könnten wir so gut wie jeden Ethereum-Client verwenden, beispielsweise Geth oder OpenEthereum (früher Parity). Da dies für das Deployen eines einzelnen Vertrags etwas zu aufwendig ist, erstellen wir hier einfach ein kostenloses Quicknode-Konto und generieren ganz unkompliziert einen Ethereum-Endpunkt. Nachdem Sie Ihren kostenlosen Ethereum-Sepolia-Endpunkt erstellt haben, halten Sie die URL Ihres HTTP-Anbieters griffbereit, da Sie diese im nächsten Abschnitt benötigen werden.

Einrichten der Konfigurationsdatei

Öffnen Sie die Datei „hardhat.config.js“ und fügen Sie den folgenden Text ein:

require("@nomiclabs/hardhat-waffle");

const endpointUrl = "ADD_YOUR_QUICKNODE_URL_HERE";
const privateKey = "ADD_YOUR_PRIVATE_KEY_HERE";

module.exports = {
  solidity: "0.8.21",
  networks: {
    sepolia: {
      url: endpointUrl,
      accounts: [privateKey],
    },
  },
};

Ersetzen Sie „ADD_YOUR_PRIVATE_KEY_HERE“ durch den privaten Schlüssel, den wir im vorherigen Schritt erhalten haben, und ersetzen Sie „ADD_YOUR_QUICKNODE_URL_HERE“ durch die HTTP-Knoten-URL, die wir im vorherigen Schritt erhalten haben, und speichern Sie die Datei.

Erläuterung zum obigen Code:

• Zeile 1: Importieren des Pakets „hardhat-waffle“.

• Zeile 3–4: Festlegen der Endpunkt-URL und des privaten Schlüssels.

• Zeilen 6–14: Angabe der Solidity-Version und Definition des Netzwerks „sepolia“.

Vertrag erstellen

Erstellen Sie nun für unseren Vertrag ein neues Verzeichnis namens „contracts“ und legen Sie darin eine neue Datei namens „HelloWorld.sol“ ab.

mkdir contracts && echo > contracts/HelloWorld.sol

Kopieren Sie den folgenden Code und fügen Sie ihn in Ihre Solidity-Datei „HelloWorld.sol “ ein:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract HelloWorld {

    string saySomething;

    constructor() {
        saySomething = "Hello World!";
    }

    function speak() public view returns(string memory) {
        return saySomething;
    }
}

Erläuterung zum obigen Code:

• Zeile 1: Angabe des SPDX-Lizenztyps; dies ist eine Ergänzung, die ab Solidity ^0.6.8 hinzugefügt wurde. 

Wenn der Quellcode eines Smart Contracts öffentlich zugänglich gemacht wird, können diese Lizenzen dazu beitragen, urheberrechtliche Probleme zu lösen bzw. zu vermeiden. Wenn Sie keine Lizenzart angeben möchten, können Sie die spezielle Lizenz „UNLICENSED“ verwenden oder den gesamten Kommentar einfach weglassen (dies führt nicht zu einem Fehler, sondern lediglich zu einer Warnung).

• Zeile 2: Angabe der Solidity-Version.

• Zeile 4: Start unseres Vertrags mit dem Namen Hallo Welt.

• Zeile 6: Eine Variable anlegen saySomething vom Typ „string“.

• Zeilen 8–10: Aufruf des Konstruktors und Speichern der Zeichenfolge „Hello World!“ in der saySomething Variable.

• Zeilen 12–14: Erstellen einer Funktion namens sprechen vom Typ „public“, der die in der saySomething Variable.

Speichern Sie die Datei und kompilieren Sie den Vertrag mit dem folgenden Hardhat-Befehl.

npx hardhat compile

Wenn Ihr Vertrag erfolgreich kompiliert wird, sieht die Ausgabe etwa so aus:

Bereitstellung des „Hello World“-Smart Contracts

Um nun unseren Vertrag bereitzustellen, erstellen wir eine Datei namens „deploy.js“ in einem neuen Verzeichnis namens „scripts“.

mkdir scripts && echo > scripts/deploy.js

Kopieren Sie den folgenden Text und fügen Sie ihn in Ihre Datei „deploy.js“ ein:

async function main() {

	const [deployer] = await ethers.getSigners();

	console.log(
	"Deploying contracts with the account:",
	deployer.address
	);

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

	console.log("Contract deployed at:", contract.address);

	const saySomething = await contract.speak();
  	
	console.log("saySomething value:", saySomething);
}

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

Erläuterung des obigen Codes.

• Zeile 1: Aufruf einer asynchronen Funktion namens Hauptseite.

• Zeile 3: Abrufen der Ethereum-Adresse zum Signieren der Transaktion und Speichern dieser Adresse in der Deployer-Adresse. 

• Zeilen 5–8: Ausgabe der Ethereum-Adresse zusammen mit einer Zeichenkette auf der Konsole.

• Zeile 10: Aufruf der Methode „ethers.js“ ContractFactory. Dabei wird nach dem HelloWorld.sol Datei und geben eine Instanz zurück, die wir verwenden können ContractFactory Methoden aktivieren.

• Zeile 11: Aufruf von „deploy“ für ContractFactory um den Vertrag umzusetzen. 

• Zeile 13: Die Adresse des bereitgestellten Vertrags wird in der Konsole ausgegeben.

• Zeile 15: Aufruf der Funktion sprechen des abgeschlossenen Vertrags.

• Zeile 17: Den Rückgabewert der Funktion ausgeben sprechen auf die Konsole.

• Zeile 20: Aufruf der Funktion Hauptseite.

• Zeilen 21–24: Auf Fehler prüfen, bei einem Fehler eine Meldung ausgeben und den Prozess beenden.

Speichern Sie die Datei und führen Sie den folgenden Befehl aus, um den Vertrag bereitzustellen.

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

Nach der erfolgreichen Bereitstellung des Vertrags wird eine Ausgabe angezeigt, die die Adresse des bereitgestellten Vertrags sowie den Rückgabewert der Funktion „speak“ – den Wert von „saySomething“ – enthält.

Wir können die Bereitstellung überprüfen, indem wir die Adresse des bereitgestellten Vertrags kopieren und in die Suchleiste von Sepolia Etherscan einfügen. Daraufhin werden Informationen zum bereitgestellten Vertrag angezeigt.

Fazit

Das war’s! Sie beherrschen nun die Grundlagen zum Erstellen, Kompilieren und Bereitstellen von Smart Contracts mit Hardhat. Aber das ist noch nicht alles – Hardhat bietet auch Tools zum Testen und Debuggen Ihres Codes. Weitere Informationen finden Sie in der offiziellen Dokumentation von Hardhat.

Abonnieren Sie unseren Newsletter, um weitere Artikel und Anleitungen zu Ethereum zu erhalten. Wenn Sie Fragen haben, nutzen Sie gerne unseren eigenen Kanal auf Discord oder geben Sie uns über das untenstehende Formular Feedback. Bleiben Sie auf dem Laufenden, indem Sie uns auf Twitter und in unserem Telegram-Ankündigungskanal folgen.

Wir ❤️ Feedback!

Teilen Sie uns gerne mit, wenn Sie Feedback oder Vorschläge für neue Themen haben. Wir freuen uns auf Ihre Rückmeldung.