12 Minuten Lesezeit

Übersicht

Digitale Sammlerstücke, die mit dem ERC-721-Standard kompatibel sind, haben seit der Einführung von Cryptokitties stark an Beliebtheit gewonnen und sich in den letzten Monaten auf dem Weg zur breiten Akzeptanz weiterentwickelt. In diesem Leitfaden wird erläutert, wie man ein NFT (ERC-721) unter Verwendung des OpenZeppelin-Standards erstellt und bereitstellt.

Möchten Sie lieber eine Videoanleitung? Folgen Sie Radek und erfahren Sie, wie Sie in 20 Minuten ein ERC-721 (NFT) erstellen und bereitstellen können.

Abonniert unseren YouTube-Kanal für weitere Videos!Abonnieren

Ihre Aufgaben

• Erfahren Sie mehr über nicht fungible Token (NFTs) und ihre Anwendungsfälle
• Erstellen Sie Metadaten für den ERC-721-Token, den Sie erstellen werden
• Laden Sie Ihre Dateien in ein dezentrales Speichersystem (IPFS) hoch
• Erstellen und implementieren Sie einen ERC-721-Token mit Remix.IDE

Was Sie benötigen

• Ein Quicknode-Endpunkt (den Sie hier kostenlos erstellen können)
• Eine Web3-Wallet (z. B. MetaMask, Coinbase Wallet, Phantom oder eine WalletConnect-kompatible Wallet) mit Test-ETH (diese kannst du über den Multi-Chain Quicknode Faucet erhalten)
• IPFS-CLI installiert
• Ein moderner Webbrowser (z. B. Chrome)

Was ist ein nicht fungibler Token?

„Fungibel“ bedeutet, dass etwas gleichwertig oder austauschbar ist. Beispielsweise haben Ethereum-Token – also alle Mitglieder einer bestimmten Token-Klasse – denselben Wert. Dasselbe gilt für Cardano-Token. Fungible Token sind im Verhältnis 1:1 austauschbar.

Vor diesem Hintergrund sind NFTs einzigartig; jedes einzelne ist anders. Jeder einzelne Token weist einzigartige Merkmale und Werte auf. Zu den Dingen, die als NFTs dienen können, gehören Sammelkarten, Kunstwerke, Flugtickets usw. Sie lassen sich alle klar voneinander unterscheiden und sind nicht austauschbar. Stellen Sie sich Non-Fungible Tokens (NFTs) als seltene Sammlerstücke vor; jedes verfügt über einzigartige Merkmale, ungewöhnliche Eigenschaften und meist auch über eigene Metadaten.

Was ist ERC-721?

ERC steht für „Ethereum Request for Comment“, und 721 ist die Identifikationsnummer des Vorschlags. ERCs sind Standards auf Anwendungsebene im Ethereum-Ökosystem; sie können beispielsweise als Smart-Contract-Standard für Token wie ERC-20 dienen. Der Verfasser eines ERC ist dafür verantwortlich, einen Konsens mit der Ethereum-Community herzustellen, und sobald der Vorschlag von der Community geprüft und genehmigt wurde, wird er zum Standard. Die aktuellen ERC-Vorschläge können Sie hier verfolgen. ERC-721 wurde entwickelt, um die Funktionalität zur Verfolgung und Übertragung von NFTs innerhalb von Smart Contracts vorzuschlagen.

ERC-721 ist ein offener Standard, der beschreibt, wie nicht fungible Token auf EVM-kompatiblen Blockchains (Ethereum Virtual Machine) erstellt werden können; es handelt sich um eine Standardschnittstelle für nicht fungible Token; er umfasst eine Reihe von Regeln, die den Umgang mit NFTs vereinfachen. NFTs gibt es nicht nur vom Typ ERC-721, sondern auch als ERC-1155-Token.

Im Folgenden sind die im ERC-721-Standard definierten Funktionen und Ereignisse aufgeführt:

ERC-721-Funktionen

balanceOf: Diese Funktion gibt die Anzahl der NFTs (Non-Fungible Tokens) zurück, die sich im Besitz einer bestimmten Adresse befinden.

ownerOf: Diese Funktion gibt die Adresse des Eigentümers eines bestimmten Tokens zurück. Jedes ERC721-Token ist einzigartig und wird durch eine ID dargestellt. Mit dieser Funktion können Benutzer oder Anwendungen anhand der eindeutigen ID den Eigentümer des Tokens ermitteln.

safeTransferFrom (ohne Daten): Diese Funktion überträgt das Eigentumsrecht an einem bestimmten Token sicher von einer Adresse auf eine andere. Die Funktion prüft, ob es sich bei dem Empfänger um einen Smart Contract handelt. Ist dies der Fall, muss dieser eine bestimmte Funktion (onERC721Received) implementieren, um die Übertragung anzunehmen.

transferFrom: Diese Funktion dient dazu, das Eigentumsrecht an einem Token von einer Adresse auf eine andere zu übertragen. Sie wird in der Regel verwendet, wenn der Absender zur Übertragung des Tokens autorisiert wurde.

Genehmigen: Diese Funktion dient dazu, einer Adresse die Genehmigung zur Übertragung eines bestimmten Tokens zu erteilen. Dies ermöglicht delegierte Übertragungen, bei denen ein Eigentümer einer anderen Partei gestatten kann, einen Token in seinem Namen zu übertragen.

getApproved: Diese Funktion dient dazu, die genehmigte Adresse für ein bestimmtes Token abzurufen. Falls für das Token keine genehmigte Adresse vorliegt, gibt diese Funktion eine Null-Adresse zurück.

setApprovalForAll: Mit dieser Funktion kann der Inhaber eines oder mehrerer Token einem Operator die Berechtigung zur Verwaltung aller seiner Token erteilen oder widerrufen.

isApprovedForAll: Mit dieser Funktion wird überprüft, ob ein Operator berechtigt ist, alle Token eines Eigentümers zu verwalten.

safeTransferFrom (mit Daten): Diese Funktion ähnelt safeTransferFrom (ohne Daten), verfügt jedoch über einen zusätzlichen Datenparameter. Diese zusätzlichen Daten können verwendet werden, um während der Übertragung weitere Informationen zu übermitteln, sofern es sich bei dem Empfänger um einen Smart Contract handelt. Diese Funktion prüft zudem, ob der Empfänger ein Smart Contract ist und ob er die Funktion „onERC721Received“ implementiert.

ERC-721-Veranstaltungen

Übertragung: Dieses Ereignis wird ausgelöst, wenn der Eigentümer eines Tokens von einer Adresse auf eine andere wechselt. Das Ereignis enthält Angaben zum Absender (from), zum Empfänger (to) und zum konkreten Token (nach ID), das übertragen wurde. Dieses Ereignis ermöglicht es externen Abhörern, wie beispielsweise Benutzeroberflächen oder anderen Verträgen, auf die Übertragung zu reagieren.

Genehmigung: Dieses Ereignis wird ausgelöst, wenn eine Adresse für die Übertragung eines bestimmten Tokens genehmigt wird. Es umfasst den aktuellen Eigentümer des Tokens (owner), die genehmigte Adresse, die den Token nun übertragen darf (approved), sowie den spezifischen Token (nach ID), dessen Übertragung genehmigt wurde. Dieses Ereignis ermöglicht es Anwendungen, Genehmigungen von Token zu verfolgen und entsprechend zu reagieren.

ApprovalForAll: Dieses Ereignis wird ausgelöst, wenn ein Eigentümer einem Operator die Berechtigung zur Verwaltung aller seiner Token erteilt oder widerruft. Es enthält die Adresse des Eigentümers (owner), die Adresse des Operators (operator) sowie einen booleschen Wert, der angibt, ob der Operator autorisiert wurde oder nicht (approved). Mit diesem Ereignis können Anwendungen nachverfolgen, welchen Adressen die Berechtigung zur Verwaltung aller Token eines bestimmten Eigentümers erteilt wurde.

Anwendungsfälle für nicht fungible Token (NFTs)

• Digitale Kunst (oder physische Kunst): Kunstwerke sind die beliebteste Anwendungsmöglichkeit für NFTs. Auktionen für digitale Kunst waren die erste Anwendung von NFTs und gewinnen weiterhin an Bedeutung.

• Gaming: Bereitstellung von In-Game-Käufen und Sammelobjekten für Spiele.

• Immobilien: Tokenisierung von Immobilien und Smart Contracts sowie Kauf und Verkauf.

• Finanzen: Finanzinstrumente wie Kredite, Terminkontrakte und sonstige Verpflichtungen.

• Softwaretitel: Softwarelizenzen zur Bekämpfung von Softwarepiraterie und zum Schutz der Privatsphäre.

• Konzertkarten/Sportveranstaltungstickets: Um sicherzustellen, dass es beim Ticketverkauf nicht zu Betrugsfällen kommt und Fans an einem einzigen Ort ihre bisherigen Erlebnisse einsehen können.

• KYC-Compliance: Erstellung eines Tokens für die KYC-Prüfung eines bestimmten Nutzers.

Test-ETH erhalten

Da wir nun wissen, was ERC-721-Token sind und wie sie funktionieren, wollen wir uns ansehen, wie wir unsere eigenen Token erstellen und bereitstellen können.

Wir werden unseren Vertrag im Ethereum-Sepolia-Testnetz bereitstellen. Um loszulegen, benötigst du die MetaMask -Browsererweiterung (oder eine andere kompatible Web3-Wallet; z. B. Phantom oder eine WalletConnect-kompatible Wallet) sowie etwas Test-ETH, das du über den Quicknode Multi-Chain Faucet erhalten kannst. Verbinde einfach deine Wallet oder füge die Adresse ein und klicke auf „Weiter“. Sie werden aufgefordert, einen Tweet zu teilen, um einen Bonus zu erhalten (wir empfehlen dies!); andernfalls klicken Sie einfach auf „Nein, danke, schickt mir einfach 0,05 ETH“. Beachten Sie, dass für die Nutzung der EVM-Faucets ein Mindestguthaben von 0,001 ETH im Ethereum-Mainnet erforderlich ist.

Dateien zu IPFS hinzufügen

Bevor wir unseren NFT-Vertrag erstellen, müssen wir unser Kunstwerk für das NFT hosten und eine Metadaten-Datei anlegen; hierfür nutzen wir IPFS – ein dezentrales Peer-to-Peer-System zur Speicherung und gemeinsamen Nutzung von Dateien. Es gibt verschiedene Möglichkeiten, das IPFS-Protokoll zu nutzen. Sie können IPFS entweder auf Ihrem eigenen System einrichten und betreiben oder sich für Quicknode als einfachere Lösung entscheiden. Quicknode vereinfacht Ihren Zugriff auf IPFS, indem es die zugrunde liegende Infrastruktur verwaltet. Dieser Ansatz ermöglicht es Ihnen, sich auf Ihre Inhalte zu konzentrieren, und entlastet Sie von der Verantwortung, einen lokalen IPFS-Knoten für das „Data Pinning“ zu unterhalten. Mit Quicknode werden die technischen Komplexitäten für Sie übernommen.

Wir behandeln beide Möglichkeiten, Ihre Dateien auf IPFS hochzuladen: über die Standard-IPFS-Befehlszeilenschnittstelle (CLI) oder über den optimierten Quicknode-IPFS-Dienst.

Standardverfahren: Verwendung der IPFS-Befehlszeilenschnittstelle (CLI)

Laden Sie die IPFS-CLI entsprechend Ihrem Betriebssystem herunter und installieren Sie sie, indem Sie die Installationsanleitung in der IPFS-Dokumentation befolgen .

Im Folgenden werden die Schritte zum Hochladen des Bildes und der Metadatendatei beschrieben.

Schritt 1: IPFS-Repo erstellen

Starten Sie das IPFS-Repo, indem Sie den folgenden Befehl in ein Terminal- bzw. CMD-Fenster eingeben.

ipfs init

Schritt 2: Starten des IPFS-Daemons

Starten Sie den IPFS-Daemon, öffnen Sie ein separates Terminal-/CMD-Fenster und geben Sie Folgendes ein.

IPFS-Daemon

Schritt 3: Ein Bild zu IPFS hinzufügen

Wechseln Sie zum ersten Terminal-Fenster und fügen Sie das Bild zu IPFS hinzu (hier: art.png).

ipfs add art.png

Kopieren Sie den mit „Qm“ beginnenden Hash und fügen Sie ihm das Präfix„https://ipfs.io/ipfs/“ hinzu; er muss in etwa so aussehen: https://ipfs.io/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg

Schritt 4: JSON-Datei zu IPFS hinzufügen

Erstellen Sie eine JSON-Datei mit dem Namen „nft.json“ und speichern Sie sie im selben Verzeichnis wie das Bild.

JSON-Dateiformat:

{
	"name": "NFT Art",
	"description": "This image shows the true nature of NFT.",
	"image": "https://ipfs.io/ipfs/QmZzBdKF7sQX1Q49CQGmreuZHxt9sVB3hTc3TTXYcVZ7jC"
}

Fügen Sie nun die JSON-Datei hinzu.

ipfs add nft.json

Nimm den Hash, der mit „Qm“ beginnt, und füge ihm„https://ipfs.io/ipfs/“ als Präfix hinzu; das Ergebnis sollte in etwa so aussehen: https://ipfs.io/ipfs/QmUFbUjAifv9GwJo7ufTB5sccnrNqELhDMafoEmZdPPng7

Speichere diese URL. Wir brauchen sie, um unser NFT zu prägen.

Quicknode IPFS-Lösung: Eine einfachere Alternative

Info

Um mehr über die Preisinformationen zu Quicknode IPFS zu erfahren, sehen Sie sich hier unsere Preispläne an.

Wenn Sie nach einem unkomplizierteren Ansatz suchen, bietet der IPFS-Dienst von Quicknode eine benutzerfreundliche und effiziente Lösung zum Hochladen Ihrer NFT-Assets. Mit Quicknode wird Ihnen die komplexe Verwaltung der Infrastruktur abgenommen, sodass Sie sich ganz auf Ihre Inhalte konzentrieren können, anstatt einen lokalen IPFS-Knoten zu betreuen.

Um Quicknode für IPFS zu nutzen, gehen Sie wie folgt vor:

Schritt 1: Bei Quicknode anmelden

Melden Sie sich bei Quicknode an und wählen Sie in der linken Seitenleiste die Option „IPFS“ aus:

Schritt 2: Hinzufügen eines Bildes zu IPFS mit Quicknode

Laden Sie Ihre Bilddatei schnell hoch, indem Sie sie per Drag & Drop verschieben oder durch Anklicken aus Ihrem Finder-/Datei-Explorer-Fenster auswählen. In dieser Anleitung verwenden wir das untenstehende Bild.

Klicken Sie nach dem Hochladen auf den Dateinamen auf der Registerkarte „Dateien“ und anschließend auf die Schaltfläche „IPFS-URL kopieren“. Ähnlich wie im folgenden Screenshot.

https://qn-shared.quicknode-ipfs.com/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg

Schritt 3: Hinzufügen einer JSON-Datei zu IPFS mit Quicknode

Erstellen Sie eine JSON-Datei mit dem Namen nft.json, ersetzen Sie Ihre IPFS-URL in der Bild Feld aus und speichern Sie es. Laden Sie Ihre JSON-Datei nach dem Speichern ähnlich wie im vorherigen Schritt auf IPFS hoch.

{
    "name": "NFT Art",
    "description": "This image shows the true nature of NFT.",
    "image": "https://qn-shared.quicknode-ipfs.com/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg"
}

Klicken Sie nach dem Hochladen auf den Dateinamen auf der Registerkarte „Dateien“ und kopieren Sie die IPFS-URL. Sie sollte in etwa so aussehen wie die unten stehende.

https://qn-shared.quicknode-ipfs.com/ipfs/QmeVHZzKGEDbEbG5MVz4hUucNf4qZTRfW18AgdJNTrv22m

Speichere diese URL. Wir brauchen sie, um unser NFT zu prägen.

Einen eigenen Token erstellen

Der Einfachheit und Sicherheit halber verwenden wir den OpenZeppelin-ERC-721-Vertrag, um unser NFT zu erstellen. Mit OpenZeppelin müssen wir nicht die gesamte ERC-721-Schnittstelle selbst schreiben. Stattdessen können wir den Bibliotheksvertrag importieren und dessen Funktionen nutzen.

Gehen Sie zur Ethereum Remix IDE und erstellen Sie eine neue Solidity-Datei, zum Beispiel „MyToken.sol“.

Fügen Sie den folgenden Code in Ihr neues Solidity-Skript ein:

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

import "@openzeppelin/contracts@5.0.0/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts@5.0.0/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts@5.0.0/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts@5.0.0/access/Ownable.sol";

contract MyToken is ERC721, ERC721URIStorage, ERC721Burnable, Ownable {
    constructor(address initialOwner)
        ERC721("MyToken", "MTK")
        Ownable(initialOwner)
    {}

    function safeMint(address to, uint256 tokenId, string memory uri)
        public
        onlyOwner
    {
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

Erläuterung zum obigen Code:

Zeile 1: Angabe des SPDX-Lizenztyps als „MIT“. Dies bedeutet, dass der Code unter der MIT-Lizenz lizenziert ist, einer freizügigen Open-Source-Lizenz, die die Nutzung, Änderung und Verbreitung des Codes mit nur sehr wenigen Einschränkungen erlaubt.

Zeile 2: Angabe der Solidity-Version als ^0.8.20. Dies bedeutet, dass der Code mit Solidity Version 0.8.20 oder einer kompatiblen Version geschrieben wurde.

Zeilen 4–7: Import der erforderlichen Verträge aus der OpenZeppelin-Bibliothek.

• ERC721.sol: Dieser Vertrag wird aus der OpenZeppelin-Bibliothek importiert und stellt die grundlegende Implementierung des ERC721-Standards dar. ERC721 ist der Standard für nicht fungible Token (NFTs).

• ERC721URIStorage.sol: Dieser Vertrag erweitert ERC721 und fügt Funktionen zum Speichern und Verwalten von Metadaten-URIs hinzu, die mit NFTs verknüpft sind. Metadaten-URIs verweisen in der Regel auf zusätzliche Informationen zum NFT.

• ERC721Burnable.sol: Dieser Vertrag erweitert ebenfalls den ERC721-Standard und fügt die Möglichkeit hinzu, NFTs zu verbrennen (zu vernichten). Er bietet eine Funktion zum dauerhaften Entfernen von NFTs aus dem Umlauf, die nur vom Eigentümer aufgerufen werden kann.

• Ownable.sol: Dieser Vertrag dient der Zugriffskontrolle. Er ermöglicht es Ihnen, einen Eigentümer festzulegen, der innerhalb des Vertrags über besondere Berechtigungen verfügt. Der Eigentümer kann bestimmte Aktionen ausführen, die anderen Benutzern nicht möglich sind.

Zeile 9: Starten des Vertrags mit dem Namen MyToken und erwähnt, dass es die Verträge ERC721, ERC721URIStorage und Ownable erweitert. Das bedeutet, dass das MyToken Der Vertrag übernimmt die in diesen Verträgen definierten Funktionen und Eigenschaften.

Zeile 10: Hier beginnt die Konstruktorfunktion. Konstruktoren sind spezielle Funktionen in Solidity, die nur einmal während der Bereitstellung des Vertrags ausgeführt werden. Dieser Konstruktor nimmt ein Argument entgegen, ursprünglicher Eigentümer, bei der es sich um eine Ethereum-Adresse handelt.

Zeile 11: In dieser Zeile wird der Konstruktor des ERC721-Vertrags mit den Argumenten „MyToken“ und „MTK“ aufgerufen. Dabei wird der NFT-Vertrag mit dem Namen „MyToken“ und dem Symbol „MTK“ initialisiert.

Zeile 12: In dieser Zeile wird der Konstruktor des „Ownable“-Vertrags aufgerufen, wobei der ursprüngliche Eigentümer des „MyToken“-Vertrags auf die als „initialOwner“ angegebene Adresse gesetzt wird.

Zeile 15: Deklaration der Funktion safeMint mit drei Argumenten: to (die Adresse des Empfängers des NFT-Tokens), tokenId (die eindeutige Kennung des Tokens) und uri (die URI der mit dem Token verknüpften JSON-Datei). Diese Funktion kann nur vom Vertragsinhaber aufgerufen werden (angegeben durch die onlyOwner Modifikator).

Zeile 19: Erstellen eines neuen Tokens durch Aufruf der _safeMint Eine vom ERC721-Vertrag geerbte Funktion. Sie erstellt einen neuen Token und weist ihn der angegebenen Empfängeradresse zu.

Zeile 20: Festlegen der mit dem Token verknüpften Token-URI (Metadaten-URI) mithilfe der _setTokenURI Funktion, die von der ERC721URIStorage Vertrag. Die URI wird anhand der angegebenen tokenId und uri festgelegt.

Zeilen 25–32: Implementierung der von Solidity geforderten Überschreibungen für die ERC721 und ERC721URIStorage Verträge. tokenURI ist eine Funktion, die die mit einer bestimmten tokenId verknüpfte Metadaten-URI abruft. Sie ist als „public“ und „view“ gekennzeichnet, was bedeutet, dass es sich um eine schreibgeschützte Funktion handelt, die von jedem aufgerufen werden kann.

Zeilen 34–41: Implementierung der Funktion „supportsInterface“, die von der ERC721 und ERC721URIStorage Verträge. Diese Funktion prüft, ob eine bestimmte „interfaceId“ vom Vertrag unterstützt wird, und gibt entsprechend einen booleschen Wert zurück.

Durch die Kombination dieser Funktionen und Verträge erstellt der Code einen benutzerdefinierten ERC721-Token-Vertrag mit dem Namen MyToken. Dieser Vertrag ermöglicht es dem Vertragsinhaber, neue Token sicher zu prägen, ihnen Metadaten-URIs zuzuordnen und die vom ERC721-Standard definierten erforderlichen Schnittstellen zu unterstützen.

Nehmen Sie sich nun einen Moment Zeit, um den Smart Contract nach Belieben mit Ihren eigenen Angaben anzupassen. Sie können den Token-Namen und das Symbol ändern, indem Sie die folgende Zeile anpassen – ERC721 („MyToken“, „MTK“).

Wenn Sie fertig sind, kompilieren Sie den Smart Contract und stellen Sie ihn bereit mit Eingebundener Anbieter (Stellen Sie sicher, dass Sie in Metamask das Sepolia-Testnetz auswählen, bevor Sie den Vertrag kompilieren.) Fügen Sie anschließend Ihre Wallet-Adresse in das Feld direkt neben dem Bereitstellen Schaltfläche, um die ursprünglicher Eigentümer Parameter der Konstruktorfunktion. Klicken Sie abschließend auf Bereitstellen auf Remix.IDE.

Sollten Sie vor der Bereitstellung die Fehlermeldung „Dieser Vertrag ist möglicherweise abstrakt“ erhalten, stellen Sie bitte sicher, dass Sie auf der Registerkarte „Vertrag“ den entsprechenden Vertrag auswählen.

Bestätigen Sie die Transaktion in Metamask:

Wechseln Sie nun in Remix zum Abschnitt „Deployed Contracts“ und klappen Sie den bereitgestellten Vertrag auf. Dort sehen Sie eine Reihe von Funktionen/Methoden. Klappen Sie die safeMint Funktion und fügen Sie die folgenden Angaben hinzu:

1. Geben Sie Ihre Wallet-Adresse in das Feld _to ein.
2. Geben Sie einen beliebigen „Big Number“-Wert in das Feld „_tokenId“ ein. Wir empfehlen die Verwendung von „1“, da dies das erste Token darstellt, das geprägt wird.
3. Für die _uri Geben Sie in das Feld die URI der JSON-Datei ein, die der von Ihnen in den vorherigen Schritten verwendeten Methode entspricht:
   • Wenn Sie die Standardmethode über die IPFS-CLI verwendet haben: Verwenden Sie die URI, die Sie nach dem Hochladen Ihrer Datei auf IPFS im Abschnitt „Standardmethode: Verwendung der IPFS-CLI“ erhalten haben. Dabei handelt es sich um den IPFS-Link, dem „https://ipfs.io/ipfs/“ vorangestellt ist, gefolgt vom Hash Ihrer Datei.
   • Wenn Sie sich für den IPFS-Dienst von Quicknode entschieden haben: Verwenden Sie die von Quicknode bereitgestellte URI, nachdem Sie Ihre Datei im Abschnitt „Quicknode IPFS-Lösung: Eine einfachere Alternative“ hochgeladen haben. Quicknode generiert eine eindeutige URI für Ihre Datei, die Sie hier eingeben sollten.

Klicken Sie auf „Transact“ und bestätigen Sie die Transaktion über MetaMask. Das kann ein paar Minuten dauern, aber Sie können jederzeit über einen Block-Explorer wie Etherscan überprüfen, ob die Transaktion ausgeführt wurde. Nun befindet sich das NFT auf der Sepolia-Chain.

Sie können weitere Details wie beispielsweise Name, Symbol, Eigentümer von, oder tokenURI indem Sie die zuvor erwähnte Token-ID eingeben.

Fazit

Herzlichen Glückwunsch zur Erstellung deines ganz persönlichen NFT! Hilf deinen Künstlerfreunden dabei, ihre Werke auf der Ethereum-Blockchain zu veröffentlichen, oder werde selbst zum Künstler. Weitere Beispiele findest du im OpenZeppelin-Assistenten.

Abonniere unseren Newsletter, um weitere Artikel und Anleitungen zu Ethereum zu erhalten. Wenn du Feedback hast, kannst du dich gerne über Twitter an uns wenden. Du kannst dich jederzeit auf unserem Discord-Community-Server mit uns unterhalten – dort findest du einige der coolsten Entwickler, die du je treffen wirst :)

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.