So erstellen und veröffentlichen Sie einen NFT (Teil 1/3 der NFT-Tutorial-Reihe)

ERC-721

Alchemy

Solidity

smart contracts

Anfänger

Sumi Mudgil

22. April 2021

14 Minuten Lesedauer

Da NFTs die Blockchain ins Rampenlicht der Öffentlichkeit rücken, ist dies eine hervorragende Gelegenheit, den Hype selbst zu verstehen, indem Sie Ihren eigenen NFT-Vertrag (ERC-721-Token) auf der Ethereum-Blockchain veröffentlichen!

Alchemy ist sehr stolz darauf, die größten Namen im NFT-Bereich zu unterstützen, darunter Makersplace (kürzlich wurde ein Rekordverkauf digitaler Kunstwerke bei Christie's für 69 Millionen USD verzeichnet), Dapper Labs (Entwickler von NBA Top Shot & Crypto Kitties), OpenSea (der weltweit größte NFT-Marktplatz), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable und viele mehr.

In diesem Tutorial führen wir Sie durch die Erstellung und Bereitstellung eines ERC-721-Smart-Contracts im Sepolia-Testnet unter Verwendung von MetaMaskopens in a new tab, Solidityopens in a new tab, Hardhatopens in a new tab, Pinataopens in a new tab und Alchemyopens in a new tab (keine Sorge, wenn Sie noch nicht verstehen, was das alles bedeutet – wir werden es erklären!).

In Teil 2 dieses Tutorials erläutern wir, wie Sie mit diesem Smart Contract einen NFT prägen können, in Teil 3 wird behandelt, wie Sie Ihren NFT auf MetaMask anzeigen können.

Wenn Sie an irgendeiner Stelle Fragen haben, können Sie sich natürlich jederzeit im Alchemy Discordopens in a new tab melden oder die NFT-API-Dokumentation von Alchemyopens in a new tab besuchen!

Schritt 1: Mit dem Ethereum-Netzwerk verbinden

Es gibt eine Reihe von Möglichkeiten, Anfragen an die Ethereum-Blockchain zu stellen, aber der Einfachheit halber verwenden wir ein kostenloses Konto bei Alchemyopens in a new tab, einer Blockchain-Entwicklerplattform und API, die es uns ermöglicht, mit der Ethereum-Chain zu kommunizieren, ohne unsere eigenen Nodes betreiben zu müssen.

In diesem Tutorial werden wir auch die Alchemy-Entwicklertools für die Überwachung und Analyse nutzen, um zu verstehen, was sich hinter unserer Smart-Contract-Bereitstellung verbirgt. Wenn Sie noch kein Alchemy-Konto haben, können Sie sich hieropens in a new tab kostenlos anmelden.

Schritt 2: Ihre App (und Ihren 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. Dies ermöglicht es uns, Anfragen an das Sepolia-Testnet zu senden. Sehen Sie sich diesen Leitfadenopens in a new tab an, wenn Sie mehr über Testnetze erfahren möchten.

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.

Benennen Sie Ihre App (wir haben „Mein erster NFT!“ gewählt), geben Sie eine kurze Beschreibung an, wählen Sie „Ethereum“ als Chain und „Sepolia“ als Ihr Netzwerk. Seit The Merge sind die anderen Testnetze veraltet.

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

Zum Versenden und Empfangen von Transaktionen benötigen Sie ein Ethereum-Konto. In diesem Tutorial verwenden wir MetaMask, eine virtuelle Wallet im Browser, mit der Sie Ihre Ethereum-Kontoadresse verwalten können. Wenn Sie mehr darüber erfahren möchten, wie Transaktionen auf Ethereum funktionieren, sehen Sie sich diese Seite der Ethereum Foundation an.

Sie können MetaMask hieropens in a new tab kostenlos herunterladen und ein Konto erstellen. Wenn Sie ein Konto erstellen oder bereits eines haben, stellen Sie sicher, dass Sie oben rechts zum „Sepolia Test Network“ wechseln (damit wir nicht mit echtem Geld arbeiten).

Schritt 4: Ether von einem Faucet hinzufügen

Um unseren Smart Contract in das Testnetzwerk integrieren zu können, benötigen wir ein paar Fake-ETH. Um ETH zu erhalten, können Sie zum von Alchemy gehosteten Sepolia Faucetopens in a new tab gehen, sich anmelden, Ihre Kontoadresse eingeben und auf „Send Me ETH“ klicken. Sie sollten kurz darauf ETH in Ihrem MetaMask-Konto sehen.

Schritt 5: Kontostand überprüfen

Um zu überprüfen, ob unser Guthaben vorhanden ist, stellen wir eine eth_getBalanceopens in a new tab-Anfrage mit dem Composer-Tool von Alchemyopens in a new tab. Das gibt den ETH-Betrag in unserem Wallet wieder. Nachdem Sie die Adresse Ihres MetaMask-Kontos eingegeben und auf “Send Request” (Anforderung senden) geklickt haben, sollten Sie eine Antwort ähnlich der Folgenden erhalten:

1`{\"jsonrpc\": \"2.0\", \"id\": 0, \"result\": \"0xde0b6b3a7640000\"}`

Hinweis: Dieses Ergebnis ist in Wei, nicht in ETH. Wei ist die kleinste Einheit von Ether. Die Umrechnung von Wei auf ETH ist: 1 ETH = 10¹⁸ Wei. Wenn wir also 0xde0b6b3a7640000 in eine Dezimalzahl konvertieren, erhalten wir 1*10¹⁸ Wei und das entspricht 1 ETH.

Puh! Unser Falschgeld ist da.

Schritt 6: Unser Projekt initialisieren

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

1mkdir my-nft
2cd my-nft

Jetzt, da wir uns in unserem Projektordner befinden, verwenden wir "npm init" um das Projekt zu starten. Wenn Sie npm noch nicht installiert haben, befolgen Sie diese Anweisungenopens in a new tab (wir benötigen auch Node.jsopens in a new tab, also laden Sie das auch herunter!).

1npm init

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

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

Genehmigen Sie die Datei "package.json" und schon kann es losgehen.

Schritt 7: Hardhatopens in a new tab installieren

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

Innerhalb unseres my-nft-Projektlaufs:

1npm install --save-dev hardhat

Weitere Details zu den Installationsanweisungenopens in a new tab finden Sie auf dieser Seite.

Schritt 8: Hardhat-Projekt erstellen

Führen Sie folgeden Befehl in unserem Projektordner aus:

1npx hardhat

Sie sollten dann eine Willkommensnachricht sehen und die Möglichkeit haben, auszuwählen, wie Sie fortfahren möchten. Wählen Sie "create an empty hardhat.config.js" (Leere hardhat.config.js erstellen) aus:

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👷 Welcome to Hardhat v2.0.11 👷‍
10? Was möchten Sie tun? …
11Ein Beispielprojekt erstellen
12❯ Eine leere hardhat.config.js erstellen
13Beenden
Alles anzeigen

Darüber wird eine hardhat.config.js-Datei für uns generiert, in der 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 der Befehlszeile zum Stammverzeichnis Ihres Projekts und geben Sie Folgendes ein:

1mkdir contracts
2mkdir scripts

contracts/ ist der Ort, an dem wir unseren NFT-Smart-Contract-Code aufbewahren werden.
scripts/ ist der Ort, an dem wir Skripte veröffentlichen und mit unseren Smart Contract interagieren.

Schritt 10: Unseren Vertrag schreiben

Jetzt, da unsere Umgebung eingerichtet ist, geht es an die aufregenderen Dinge: das Schreiben unseres Smart-Contract-Codes!

Öffnen Sie das my-nft-Projekt in Ihrem bevorzugten Editor (wir mögen VSCodeopens in a new tab). Smart Contracts werden in einer Sprache namens Solidity geschrieben. Damit werden wir auch unseren Smart Contract MyNFT.sol schreiben.

Navigieren Sie zum contracts-Ordner und erstellen Sie eine neue Datei namens MyNFT.sol.

Nachfolgend finden Sie unseren NFT-Smart-Contract-Code, der auf der ERC-721-Implementierung der OpenZeppelinopens in a new tab-Bibliothek basiert. Kopieren Sie folgenden Inhalt und fügen Sie ihn in die Datei MyNFT.sol ein.

1//Vertrag basiert auf [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
2// SPDX-License-Identifier: MIT
3pragma solidity ^0.8.0;
4
5import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
6import "@openzeppelin/contracts/utils/Counters.sol";
7import "@openzeppelin/contracts/access/Ownable.sol";
8import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
9
10contract MyNFT is ERC721URIStorage, Ownable {
11    using Counters for Counters.Counter;
12    Counters.Counter private _tokenIds;
13
14    constructor() ERC721("MyNFT", "NFT") {}
15
16    function mintNFT(address recipient, string memory tokenURI)
17        public onlyOwner
18        returns (uint256)
19    {
20        _tokenIds.increment();
21
22        uint256 newItemId = _tokenIds.current();
23        _mint(recipient, newItemId);
24        _setTokenURI(newItemId, tokenURI);
25
26        return newItemId;
27    }
28}
Alles anzeigen

Da wir Klassen aus der OpenZeppelin-contracts-Bibliothek erben, führen Sie in Ihrer Kommandozeile npm install @openzeppelin/contracts^4.0.0 aus, um die Bibliothek in unserem Ordner zu installieren.

Was also tut dieser Code genau? Sehen wir uns das gemeinsam Zeil für Zeile an.

Ganz oben in unserem Smart-Contract importieren wir drei OpenZeppelinopens in a new tab-Smart-Contract-Klassen:

@openzeppelin/contracts/token/ERC721/ERC721.sol enthält eine Implementierung des ERC-721-Standards, den unser NFT-Smart-Contract erben wird. (Damit der NFT auch Gültikeit erlangt, muss Ihr Smart Contract alle Methoden des ERC-721-Standards implementieren.) Um mehr über die geerbten ERC-721-Funktionen zu erfahren, sehen Sie sich die Schnittstellendefinition hieropens in a new tab an.
@openzeppelin/contracts/utils/Counters.sol stellt Zähler zur Verfügung, die jeweils nur um eins erhöht oder verringert werden können. Unser Smart Contract benutzt einen Zähler, um die Gesamtanzahl der geprägten NFTs zu überprüfen und eine eindeutige ID für unseren neuen NFT festzulegen. (Jedem NFT, der durch die Benutzung eines Smart Contracts geprägt wird, muss eine eindeutige ID zugewiesen werden. In diesem Beispiel wird unsere eindeutige ID einfach deterministisch über die Gesamtanzahl der existierenden NFTs bestimmt. Zum Beispiel hat der erste NFT, der mit unserem Smart Contract geprägt wird, die ID "1", unser zweiter NFT hat die ID "2" usw.)
@openzeppelin/contracts/access/Ownable.sol richtet eine Zugriffskontrolleopens in a new tab für unseren Smart-Contract ein, sodass nur der Eigentümer des Smart-Contracts (also Sie) NFTs prägen kann. (Hinweis, die Einbeziehung der Zugriffskontrolle ist optional. Wenn Sie möchten, dass mit Ihrem Smart Contract jeder NFTs prägen kann, entfernen Sie das Wort "Ownable" in Zeile 10 und "onlyOwner" in Zeile 17.)

Nach unseren Importanweisungen haben wir unseren benutzerdefinierten Smart Contract, der überraschend kurz ist , denn er enthält nur einen Zähler, einen Konstruktor und eine einzige Funktion. Dies ist den von uns geerbten OpenZeppelin-Contracts zu verdanken, die die meisten der Methoden implementieren, die wir zum Erstellen eines NFT benötigen, wie z. B. ownerOf, das den Eigentümer des NFT zurückgibt, und transferFrom, das das Eigentum am NFT von einem Konto auf ein anderes überträgt.

Sie werden feststellen, dass wir in unserem ERC-721-Konstruktor zwei Zeichenfolgen übergeben: "MyNFT" und "NFT". Die erste Variable ist der Name des Smart Contracts und die zweite ist sein Symbol. Sie können jede der beiden Variablen benennen wie sie möchten.

Schließlich haben wir unsere Funktion mintNFT(address recipient, string memory tokenURI), die es uns ermöglicht, einen NFT zu prägen! Sie werden bemerken, dass diese Funktion zwei Variablen benötigt:

address recipient gibt die Adresse an, die Ihren frisch geprägten NFT erhalten wird
string memory tokenURI ist ein String, der in ein JSON-Dokument aufgelöst werden sollte, das die Metadaten des NFTs beschreibt. Die Metadaten eines NFT, sind das Element, das den NFT wirklich zum Leben erwecken. Sie schaffen die Grundlage, dass ein NFT konfigurierbare Eigenschaften wie einen Namen, eine Beschreibung ein Bild und andere Attribute haben kann. In Teil 2 dieses Tutorials wird die Konfiguration dieser Metadaten beschrieben.

mintNFT ruft einige Methoden aus der geerbten ERC-721-Bibliothek auf und gibt schließlich eine Zahl zurück, die die ID des frisch geprägten NFT darstellt.

Schritt 11: MetaMask & Alchemy mit Ihrem Projekt verbinden

Nachdem wir nun eine MetaMask-Wallet und ein Alchemy-Konto erstellt uns unseren Smart Contract geschrieben haben, ist es an der Zeit, die drei Elemente miteinander zu verbinden.

Jede Transaktion, die von Ihrer virtuellen Wallet gesendet wird, benötigt eine Signatur mit ihrem eindeutigen privaten Schlüssel. Um unser Programm mit dieser Berechtigung auszustatten, können wir unseren privaten Schlüssel (und Alchemy-API-Schlüssel) in einer Umgebungsdatei sicher abspeichern.

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

Installieren Sie zuerst das dotenv-Paket in Ihrem Projektverzeichnis:

1npm install dotenv --save

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

Befolgen Sie diese Anweisungenopens in a new tab, um Ihren privaten Schlüssel aus MetaMask zu exportieren
Unten wird erläutert, wie Sie die HTTP-URL der Alchemy-API erhalten und in die Zwischenablage kopieren.

Ihre .env-Datei sollte jetzt so aussehen:

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

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

Führe .env nicht aus! Es wird dringend davon abgeraten, Deine persönlichen Daten, die in dieser Datei.env enthalten sind, auszustellen oder sie mit anderen Personen zu teilen, da dies die Vertraulichkeit Deiner persönlichen Daten gefährden könnte. Wenn eine Systemsteuerung schon vorhanden ist, füge in die Datei gitignore Deinen.env ein.

Schritt 12: Ethers.js installieren

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

Hardhat macht es sehr einfach, Pluginsopens in a new tab für zusätzliche Tools und erweiterte Funktionalität zu integrieren. Wir werden das Ethers-Pluginopens in a new tab für die Vertragsbereitstellung nutzen (Ethers.jsopens in a new tab verfügt über einige sehr saubere Methoden zur Vertragsbereitstellung).

Geben Sie Folgendes in Ihrem Projektverzeichnis ein:

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

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:

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

Schritt 14: Unseren Vertrag kompilieren

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

Möglicherweise erhalten Sie eine Warnung, dass die SPDX-Lizenzkennung nicht in Quelldatei angegeben sei. Doch darüber brauchen Sie sich keine Sorgen zu machen. Alles andere sieht hoffentlich gut aus. Wenn nicht, können Sie jederzeit eine Nachricht im Alchemy-Discordopens in a new tab schreiben.

Schritt 15: Unser 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 scripts/-Ordner und erstellen Sie eine neue Datei namens deploy.js, indem Sie die folgenden Inhalte hinzufügen:

1async function main() {
2  const MyNFT = await ethers.getContractFactory("MyNFT")
3
4  // Bereitstellung starten, die ein Promise zurückgibt, das zu einem Vertragsobjekt aufgelöst wird
5  const myNFT = await MyNFT.deploy()
6  await myNFT.deployed()
7  console.log("Contract deployed to address:", myNFT.address)
8}
9
10main()
11  .then(() => process.exit(0))
12  .catch((error) => {
13    console.error(error)
14    process.exit(1)
15  })
Alles anzeigen

Hardhat erklärt in seinem Contracts-Tutorialopens in a new tab hervorragend, was jede dieser Codezeilen bewirkt; wir haben die Erklärungen hier übernommen.

1const MyNFT = await ethers.getContractFactory("MyNFT");

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

1const myNFT = await MyNFT.deploy();

Mit dem Aufruf von deploy() über eine ContractFactory wird die Bereitstellung gestartet. Zurückgegeben wird eine Referenz, die auf einen Vertrag zeigt. Das ist das Objekt, das eine Methode für jede unserer Smart-Contract-Funktionen enthält.

Schritt 16: Unseren Vertrag bereitstellen

Nun sind wir endlich bereit, unseren Smart Contract bereitzustellen. Navigieren Sie zurück zu Ihrem Stammverzeichnis und führen Sie Folgendes über die Befehlszeile aus:

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

Sie sollten dann etwas sehen wie:

1Vertrag bereitgestellt für Adresse: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

Wenn wir zum Sepolia Etherscanopens in a new tab gehen und nach unserer Vertragsadresse suchen, sollten wir sehen können, dass sie erfolgreich bereitgestellt wurde. Wenn sie nicht sofort angezeigt wird, haben Sie etwas Geduld, denn dieser Vorgang kann einige Zeit in Anspruch nehmen. Die Transaktion wird ungefähr so aussehen:

Die From-Adresse sollte mit Ihrer MetaMask-Kontoadresse übereinstimmen und die To-Adresse lautet „Contract Creation“. Wenn wir auf die Transaktion klicken ,sehen wir unsere Vertragsadresse im Empfängerfeld:

Großartig! Sie haben soeben Ihren NFT-Smart-Contract in der Ethereum-Chain (Testnet) bereitgestellt!

Um zu verstehen, was unter der Haube vor sich geht, navigieren wir zum Explorer-Tab in unserem Alchemy-Dashboardopens in a new tab. Wenn Sie mehrere Alchemy-Apps besitzen, filtern Sie nach Apps und wählen Sie "MyNFT" aus.

Hier sehen Sie eine Handvoll JSON-RPC-Aufrufe, die Hardhat/Ethers implementiert hat, als wir die .deploy()-Funktion aufgerufen haben. Zwei wichtige Aufrufe sind hier eth_sendRawTransaction, das ist die Anfrage, um unseren Smart-Contract tatsächlich in die Sepolia-Chain zu schreiben, und eth_getTransactionByHash, eine Anfrage zum Lesen von Informationen über unsere Transaktion anhand des Hashes (ein typisches Muster beim Senden von Transaktionen). Um mehr über das Senden von Transaktionen zu erfahren, lesen Sie dieses Tutorial über das Senden von Transaktionen mit Web3.

Damit sind wir am Ende vom ersten Teil dieses Tutorials. In Teil 2 werden wir tatsächlich mit unserem Smart-Contract interagieren, indem wir einen NFT prägen, und in Teil 3 zeigen wir Ihnen, wie Sie Ihren NFT in Ihrer Ethereum-Wallet ansehen können!

Seite zuletzt aktualisiert: 5. Dezember 2025