Weiter zum Hauptinhalt

Helfen Sie mit, diese Seite zu aktualisieren

🌏

Es gibt eine neue Version dieser Seite, aber im Moment ist sie nur auf Englisch verfügbar. Helfen Sie mit, die neueste Version zu übersetzen.

Seite übersetzen
In Englisch

Hier sind keine Fehler!🐛

Diese Seite wird nicht übersetzt. Wir haben diese Seite bewusst vorerst auf Englisch belassen.

Hello World-Smart Contract für Einsteiger

SolidityHardhatAlchemySmart ContractsErste SchritteBereitstellung
page-tutorial-undefined
✍️elanh
📆31. März 2021
⏱️12 Minuten Lesedauer

Wenn Sie neu in der Blockchain-Entwicklung sind und nicht wissen, wo Sie anfangen sollen, oder wenn Sie einfach nur verstehen wollen, wie man Smart Contracts einsetzt und mit ihnen interagiert, ist dieser Leitfaden genau das Richtige für Sie. Wir werden die Erstellung und den Einsatz eines einfachen Smart Contracts auf dem Ropsten-Testnet unter Verwendung einer virtuellen Wallet erläutern (MetaMask), Solidity, Hardhat and Alchemy (Machen Sie sich keine Sorgen, wenn Sie noch nicht verstehen, was das alles bedeutet. Wir werden es Ihnen erklären).

Im zweiten Teil dieses Tutorials werden wir erläutern, wie wir mit unserem Smart Contract interagieren können, sobald er bereitgestellt wurde. Im dritten Teil erläutern wir dann, wie er auf Etherscan veröffentlicht wird.

Wenn Sie zu irgendeinem Zeitpunkt Fragen haben, dann können Sie sich im Alchemy Discord melden.

Schritt 1: Verbindung mit dem Ethereum-Netzwerk

Es gibt viele Möglichkeiten, Anfragen an die Ethereum-Chain zu stellen. Der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemy, eine Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne dass wir unseren eigenen Node betreiben müssen. Die Plattform verfügt auch über Entwickler-Tools für die Überwachung und Analyse, die wir in diesem Tutorial nutzen werden, um zu verstehen, was unter der Haube der Smart-Contract-Bereitstellung vor sich geht. Wenn Sie noch kein Alchemy-Konto haben, können Sie sich hier kostenlos anmelden.

Schritt 2: Anwendung (und den API-Schlüssel) erstellen

Sobald Sie ein Alchemy-Konto erstellt haben, können Sie einen API-Schlüssel generieren. Erstellen Sie dafür eine App. Darüber können wir Anfragen an das Ropsten-Testnet stellen. Wenn Sie mit Testnets nicht vertraut sind, lesen Sie diese Seite.

  1. Klicken Sie in Ihrem Alchemy-Dashboard in der Navigationsleiste unter "Apps" auf "Create App" (App erstellen), um auf die Seite "Create App" (App erstellen) zu gelangen.

Hello World-App erstellen

  1. Nennen Sie Ihre App "Hello World", geben Sie eine kurze Beschreibung an, wählen Sie "Staging" für die Umgebung (die für die Buchhaltung Ihrer App verwendet wird) und wählen Sie "Ropsten" als Netzwerk.

Hello World-App-Ansicht erstellen

  1. Klicken Sie auf “Create app” (App erstellen) und schon sind Sie fertig. Die App sollte in der untenstehenden Tabelle erscheinen.

Schritt 3: Ethereum-Konto (Adresse) erstellen

Wir benötigen ein Ethereum-Konto, um Transaktionen zu senden und zu empfangen. In diesem Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, mit der Sie Ihre Ethereum-Kontoadresse verwalten können. Weitere Informationen zu Transaktionen.

Sie können MetaMask hier kostenlos herunterladen und ein Konto erstellen. Wenn Sie ein Konto erstellen oder wenn Sie bereits ein Konto haben, stellen Sie sicher, dass Sie oben rechts zum "Ropsten-Testnet" wechseln (damit wir nicht mit echtem Geld arbeiten).

Beispiel MetaMask Ropsten

Schritt 4: Ether von einem Faucet hinzufügen

Um unseren Smart Contract im Testnet einzusetzen, benötigen wir einige Fake-ETH. Um ETH zu erhalten, können Sie auf den Ropsten Faucet gehen und Ihre Ropsten-Kontoadresse eingeben. Klicken Sie dann auf "Ropsten-ETH senden". Aufgrund des Netzwerkverkehrs kann es einige Zeit dauern, bis Sie Ihre Fake-ETH erhalten. Sie sollten kurz darauf ETH auf Ihrem MetaMask-Konto sehen.

Schritt 5: Guthaben prüfen

Um unser Guthaben zu überprüfen, müssen wir eine eth_getBalance-Anfrage mit dem dem Composer-Tool von Alchemy stellen. Dadurch wird der Betrag der ETH in unsere Wallet zurückgegeben. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf "Anfrage senden" geklickt haben, sollten Sie eine Antwort wie diese erhalten:

1{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
2
📋 Kopieren

HINWEIS: Dieses Ergebnis ist in Wei und nicht in ETH. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei auf ETH ist: 1 ETH = 1018 Wei. Wenn wir also 0x2B5E3AF16B1880000 in eine Dezimalzahl konvertieren, bekommen wir 5*10¹⁸. Das entspricht 5 ETH.

Puh! Unser Falschgeld ist da 🤑.

Schritt 6: Projekt initialisieren

Zunächst müssen wir einen Ordner für unser Projekt erstellen. Navigieren Sie zur Befehlszeile und geben Sie Folgendes ein:

1mkdir hello-world
2cd hello-world
3

Wir befinden uns nun in unserem Projektordner. Mit npm init starten wir das Projekt. Wenn Sie npm noch nicht installiert haben, befolgen Sie diese Anleitung (wir brauchen auch Node.js, also laden Sie das auch herunter).

1npm init
2

Es spielt keine Rolle, wie Sie die Fragen zur Installation beantworten. Wir haben es folgendermaßen gemacht:

1package name: (hello-world)
2version: (1.0.0)
3description: hello world smart contract
4entry point: (index.js)
5test command:
6git repository:
7keywords:
8author:
9license: (ISC)
10About to write to /Users/.../.../.../hello-world/package.json:
11
12{
13 "name": "hello-world",
14 "version": "1.0.0",
15 "description": "hello world smart contract",
16 "main": "index.js",
17 "scripts": {
18 "test": "echo \\"Error: no test specified\\" && exit 1"
19 },
20 "author": "",
21 "license": "ISC"
22}
23
Alles zeigen

Genehmigen Sie die package.json und es kann losgehen.

Schritt 7: Hardhat{#step-7} installieren

Hardhat ist eine Entwicklungsumgebung zum Kompilieren, Bereitstellen, Testen und Debuggen Ihrer Ethereum-Software. Es hilft Entwicklern bei der lokalen Erstellung von Smart Contracts und dApps, bevor diese auf der Live-Chain bereitgestellt werden.

Führen Sie innerhalb unseres hello-world-Projekts folgenden Befehl aus:

1npm install --save-dev hardhat
2

Auf dieser Seite finden Sie weitere Informationen zur Installationsanleitung.

Schritt 8: Hardhat-Projekt erstellen

Führen Sie in unserem Projektordner folgenden Befehl aus:

1npx hardhat
2

Sie sollten eine Willkommensnachricht sehen und die Möglichkeit haben, auszuwählen, was Sie tun möchten. Wählen Sie "create an empty hardhat.config.js" (Eine leere hardhat.config.js erstellen):

1888 888 888 888 888
2888 888 888 888 888
3888 888 888 888 888
48888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
5888 888 "88b 888P" d88" 888 888 "88b "88b 888
6888 888 .d888888 888 888 888 888 888 .d888888 888
7888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
8888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
9
10👷 Welcome to Hardhat v2.0.11 👷‍?
11
12Was möchten Sie tun? …
13Create a sample project
14❯ Create an empty hardhat.config.js
15Quit
16
Alles zeigen

Darüber wird eine hardhat.config.js-Datei für uns erstellt, in der wir alle Einstellungen für unser Projekt angeben werden (in Schritt 13).

Schritt 9: Projektordner hinzufügen

Um unser Projekt zu organisieren, erstellen wir zwei neue Ordner. Navigieren Sie in Ihrer Befehlszeile zum Stammverzeichnis Ihres Projekts und geben Sie Folgendes ein:

1mkdir contracts
2mkdir scripts
3
  • contracts/ ist der Ort, an dem wir unseren hello world-Smart-Contract-Code ablegen
  • scripts/ ist der Ort, an dem wir Skripte zum Einsatz und zur Interaktion mit unserem Vertrag aufbewahren

Schritt 10: Vertrag schreiben

Sie fragen sich vielleicht, wann fangen wir endlich an, den Code zu schreiben? Jetzt! In Schritt 10.

Öffnen Sie das hello-world-Projekt in Ihrem bevorzugten Editor (wir bevorzugen VSCode). Smart Contracts werden in einer Sprache namens Solidity geschrieben, die wir verwenden werden, um unseren Smart Contract namens HelloWorld.sol zu schreiben.

  1. Navigieren Sie zum Ordner "contracts" (Verträge) und erstellen Sie eine neue Datei namens HelloWorld.sol.
  2. Im Folgenden finden Sie ein Beispiel für einen Hello World-Smart Contract der Ethereum Foundation, den wir für dieses Tutorial verwenden. Kopieren Sie den folgenden Inhalt und fügen Sie ihn in Ihre Datei HelloWorld.sol ein. Lesen Sie die Kommentare, um zu verstehen, was dieser Vertrag bewirkt:
1// Bestimmt die Version von Solidity mit semantischer Versionierung.
2// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
3pragma solidity ^0.7.0;
4
5// Defines a contract named `HelloWorld`.
6// Ein Smart contract ist eine Sammlung von Funktionen und Daten (sein Zustand). Einmal in die Blockchain integriert, befindet sich ein Contract an einer bestimmten Adresse der Ethereum-Blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
7contract HelloWorld {
8
9 // Declares a state variable `message` of type `string`.
10 // Zustandsvariablen sind Variablen, deren Werte dauerhaft im Vertragsspeicher hinterlegt werden. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
11 string public message;
12
13 // Ähnlich wie viele Klassen-basierte objektorientierte Sprachen, ist ein Konstruktor
14 // eine spezielle Funktion, die nur bei der Vertragserstellung ausgeführt wird.
15 // Konstruktoren werden verwendet, um die Vertragsdaten zu initialisieren. Erfahre mehr: https://solidity.readthedocs.io/de/v0.5.10/contracts. tml#constructors
16 constructor(string memory initMessage) public {
17 // Akzeptiert ein String Argument `initMessage` und setzt den Wert
18 // in die `message` Speichervariable des Contracts).
19 message = initMessage;
20 }
21
22 // Eine öffentliche Funktion, die ein String-Argument akzeptiert
23 // und die Speichervariable `message` aktualisiert.
24 function update(string memory newMessage) public {
25 message = newMessage;
26 }
27}
28
Alles zeigen
📋 Kopieren

Das ist ein sehr einfacher Smart Contract, der eine Nachricht bei Erstellung speichert und durch den Aufruf der update-Funktion aktualisiert werden kann.

Schritt 11: MetaMask und Alchemy mit Ihrem Projekt verbinden

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

Jede Transaktion, die von Ihrer virtuellen Wallet gesendet wird, erfordert eine Unterschrift mit Ihrem einzigartigen privaten Schlüssel. Um unser Programm mit dieser Berechtigung auszustatten, können wir unseren privaten Schlüssel (und den Alchemy-API-Schlüssel) sicher in einer Umgebungsdatei speichern.

Weitere Informationen zum Senden von Transaktionen finden Sie in diesem Tutorial zum Senden von Transaktionen mit web3.

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

1npm install dotenv --save
2

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

  • Befolgen Sie diese Anweisungen, um Ihren privaten Schlüssel zu exportieren.
  • Unten sehen Sie, wie Sie die HTTP-Alchemy API-URL erhalten.

Alchemy-API-Schlüssel erhalten

Alchemy-API-URL kopieren

Unser .env sollte dann so aussehen:

1API_URL = "https://eth-ropsten.alchemyapi.io/v2/your-api-key"
2PRIVATE_KEY = "your-metamask-private-key"
3

Um diese mit unserem Code zu verbinden, werden wir diese Variablen in unserer hardhat.config.js-Datei in Schritt 13 referenzieren.

Führen Sie keinen Commit für .env aus. Stellen Sie sicher, dass Sie Ihre .env-Datei niemals an andere weitergeben, denn damit würden Sie Ihre geheimen Daten weitergeben. Wenn Sie die Versionskontrolle verwenden, fügen Sie Ihre Env-Datei zu einer Datei gitignore hinzu.

Schritt 12: Ethers.js installieren

Ethers.js ist eine Bibliothek, die es einfacher macht, mit Ethereum zu interagieren und Anfragen zu stellen. Dafür schließt sie Standard-JSON-RPC-Methoden in benutzerfreundlichere Methoden ein.

Hardhat macht es sehr einfach Plug-ins für zusätzliche Tools und erweiterte Funktionen zu integrieren. Wir werden das Ethers-Plug-in für die Bereitstellung von Verträgen nutzen (Ethers.js bietet einige sehr saubere Methoden zur Bereitstellung von Verträgen).

Geben Sie Folgendes in Ihrem Projektverzeichnis ein:

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

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

Schritt 13: hardhat.config.js aktualisieren

Wir haben bisher mehrere Abhängigkeiten und Plug-ins hinzugefügt. Jetzt müssen wir hardhat.config.js aktualisieren, damit unser Projekt über alle diese Abhängigkeiten informiert wird.

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

1require('dotenv').config();
2
3require("@nomiclabs/hardhat-ethers");
4const { API_URL, PRIVATE_KEY } = process.env;
5
6/**
7* @type import('hardhat/config').HardhatUserConfig
8*/
9module.exports = {
10 solidity: "0.7.3",
11 defaultNetwork: "ropsten",
12 networks: {
13 hardhat: {},
14 ropsten: {
15 url: API_URL,
16 accounts: [`0x${PRIVATE_KEY}`]
17 }
18 },
19}
20
Alles zeigen

Schritt 14: Vertragszusammenstellung

Um sicherzugehen, dass so weit alles funktioniert, sollten wir unseren Vertrag erstellen. Die Aufgabe compile ist eine der integrierten Hardhat-Aufgaben.

Führen Sie folgenden Befehl in der Befehlszeile aus:

1npx hardhat compile
2

Möglicherweise erhalten Sie eine Warnung über SPDX license identifier not provided in source file (SPDX-Lizenzkennung nicht in Quelldatei angegeben), aber darüber brauchen Sie sich keine Sorgen zu machen. Alles andere sieht hoffentlich gut aus. Falls nicht, können Sie jederzeit eine Nachricht im Alchemy Discord hinterlassen.

Schritt 15: Bereitstellungsskript schreiben

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

Navigieren Sie zum Ordner scripts/ und erstellen Sie eine neue Datei namens deploy.js. Fügen Sie folgende Inhalte hinzu:

1async function main() {
2 const HelloWorld = await ethers.getContractFactory("HelloWorld");
3
4 // Start deployment, returning a promise that resolves to a contract object
5 const hello_world = await HelloWorld.deploy("Hello World!");
6 console.log("Contract deployed to address:", hello_world.address);}
7
8main()
9 .then(() => process.exit(0))
10 .catch(error => {
11 console.error(error);
12 process.exit(1);
13 });
14
Alles zeigen

Hardhat erklärt in seinem Vertragstutorial sehr gut, was die einzelnen Codezeilen bewirken. Wir haben diese Erklärungen hier übernommen.

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

Eine ContractFactory in ethers.js ist eine Abstraktion, die dazu dient, neue Smart Contracts einzusetzen. So ist HelloWorld eine Factory for Instances von unseren hello world-Vertrag. Wenn Sie das hardhat-ethers-Plug-in verwenden, werden die Instanzen ContractFactory und Contract standardmäßig mit dem ersten Unterzeichner verbunden.

1const hello_world = await HelloWorld.deploy();
2

Der Aufruf eines deploy() im ContractFactory startet die Bereitstellung und gibt einen Promise zurück, was zum Contract führt. Das ist das Objekt, das eine Methode für jede unserer Smart-Contract-Funktionen enthält.

Schritt 16: Vertragsbereitstellung

Nun sind wir endlich bereit, unseren Smart Contract bereitzustellen. Navigieren Sie zur Befehlszeile und führen Sie folgenden Befehl aus:

1npx hardhat run scripts/deploy.js --network ropsten
2

Sie sollten dann etwas sehen wie:

1Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
2

Wenn wir den Ropsten etherscan aufrufen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass sie erfolgreich bereitgestellt wurde. Das Ergebnis sollte etwa wie folgt aussehen:

Etherscan-Vertrag

Die From-Adresse sollte mit Ihrer MetaMask-Kontoadresse übereinstimmen und für die To-Adresse wird “Contract Creation” (Vertragserstellung) angezeigt. Doch wenn Sie die Transaktion aufrufen, erkennen Sie unsere Vertragsadresse im To-Feld:

Etherscan-Transaktion

Herzlichen Glückwunsch! Sie haben gerade einen Smart Contract in der Ethereum.Chain hinzugefügt 🎉.

Um zu verstehen, was im Verborgenen vor sich geht, navigieren wir zur Explorer-Registerkarte in unserem Alchemy-Dashboard. Wenn Sie mehrere Alchemy-Anwendungen haben, stellen Sie sicher, dass Sie nach Anwendungen filtern und "Hello World" auswählen. Hello World-Explorer

Hier sehen Sie eine Handvoll JSON-RPC-Befehle, die Hardhat/Ethers implementiert hat, als wir die .deploy()-Funktion aufgerufen haben. Zwei wichtige Befehle, die wir hier vorstellen möchten, sind eth_sendRawTransaction, das ist die Aufforderung unseren Vertrag in die Ropsten-Chain zu schreiben, und eth_getTransactionByHash, was eine Anfrage ist, Informationen über unsere Transaktion anhand des Hashs zu lesen (ein typisches Muster bei Transaktionen). Wenn Sie mehr über das Senden von Transaktionen erfahren möchten, lesen Sie dieses Tutorial über das Senden von Transaktionen mit Web3

Damit sind wir am Ende des ersten Teils von diesem Tutorial. Im zweiten Teil werden wir mit unserem Smart Contract interagieren. Dafür aktualisieren wir unsere anfängliche Nachricht. Im dritten Teil 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. Sie möchten kein Update verpassen? Dann abonnieren Sie hier unseren Newsletter. Folgen Sie uns auf Twitter und treten Sie unserer Community in Discord bei.

Letzte Änderung: , Invalid DateTime
Seite bearbeiten

War diese Seite hilfreich?