Wie man einen NFT prägt (Teil 2/3 der NFT-Tutorial-Reihe)

ERC-721

Alchemy

Solidity

Smart Contracts

Anfänger

Sumi Mudgil

22. April 2021

9 Minuten Lesezeit

Beeple (opens in a new tab): 69 Millionen $ 3LAU (opens in a new tab): 11 Millionen $ Grimes (opens in a new tab): 6 Millionen $

Sie alle haben ihre NFTs mithilfe der leistungsstarken API von Alchemy geprägt. In diesem Tutorial zeigen wir Ihnen, wie Sie in <10 Minuten dasselbe tun können.

„Einen NFT prägen“ ist der Vorgang, eine einzigartige Instanz Ihres ERC-721-Tokens auf der Blockchain zu veröffentlichen. Lassen Sie uns mit unserem Smart Contract aus Teil 1 dieser NFT-Tutorial-Reihe unsere Web3-Fähigkeiten unter Beweis stellen und einen NFT prägen. Am Ende dieses Tutorials werden Sie in der Lage sein, so viele NFTs zu prägen, wie Ihr Herz (und Ihre Wallet) begehrt!

Lassen Sie uns anfangen!

Schritt 1: Web3 installieren

Wenn Sie das erste Tutorial zur Erstellung Ihres NFT-Smart-Contracts befolgt haben, haben Sie bereits Erfahrung mit Ethers.js. Web3 ist ähnlich wie Ethers, da es sich um eine Bibliothek handelt, die das Erstellen von Anfragen an die Ethereum-Blockchain erleichtert. In diesem Tutorial verwenden wir Alchemy Web3 (opens in a new tab), eine erweiterte Web3-Bibliothek, die automatische Wiederholungsversuche und robuste WebSocket-Unterstützung bietet.

Führen Sie in Ihrem Projekt-Stammverzeichnis Folgendes aus:

1npm install @alch/alchemy-web3

Schritt 2: Eine `mint-nft.js`-Datei erstellen

Erstellen Sie in Ihrem Skriptverzeichnis eine Datei namens mint-nft.js und fügen Sie die folgenden Codezeilen hinzu:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
4const web3 = createAlchemyWeb3(API_URL)

Schritt 3: Holen Sie sich Ihre Vertrags-ABI

Unsere Vertrags-ABI (Application Binary Interface) ist die Schnittstelle zur Interaktion mit unserem Smart Contract. Mehr über Vertrags-ABIs erfahren Sie hier (opens in a new tab). Hardhat generiert automatisch eine ABI für uns und speichert sie in der Datei MyNFT.json. Um diese zu verwenden, müssen wir den Inhalt parsen, indem wir die folgenden Codezeilen zu unserer Datei mint-nft.js hinzufügen:

1const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")

Wenn Sie die ABI sehen möchten, können Sie sie in Ihrer Konsole ausgeben:

1console.log(JSON.stringify(contract.abi))

Um mint-nft.js auszuführen und Ihre ABI in der Konsole ausgeben zu lassen, navigieren Sie zu Ihrem Terminal und führen Sie Folgendes aus:

1node scripts/mint-nft.js

Schritt 4: Konfigurieren Sie die Metadaten für Ihren NFT mit IPFS

Wenn Sie sich an unser Tutorial in Teil 1 erinnern, nimmt unsere Smart-Contract-Funktion mintNFT einen tokenURI-Parameter entgegen, der auf ein JSON-Dokument verweisen sollte, das die Metadaten des NFTs beschreibt – was den NFT erst wirklich zum Leben erweckt und ihm konfigurierbare Eigenschaften wie Name, Beschreibung, Bild und andere Attribute verleiht.

Das Interplanetary File System (IPFS) ist ein dezentralisiertes Protokoll und Peer-to-Peer-Netzwerk zum Speichern und Teilen von Daten in einem verteilten Dateisystem.

Wir werden Pinata verwenden, eine praktische IPFS-API und ein Toolkit, um unser NFT-Asset und die Metadaten zu speichern und sicherzustellen, dass unser NFT wirklich dezentralisiert ist. Wenn Sie noch kein Pinata-Konto haben, melden Sie sich hier (opens in a new tab) für ein kostenloses Konto an und führen Sie die Schritte zur Verifizierung Ihrer E-Mail-Adresse durch.

Sobald Sie ein Konto erstellt haben:

Navigieren Sie zur Seite „Files“ (Dateien) und klicken Sie oben links auf die blaue Schaltfläche „Upload“ (Hochladen).
Laden Sie ein Bild auf Pinata hoch – dies wird das Bild-Asset für Ihren NFT sein. Sie können das Asset nach Belieben benennen.
Nach dem Hochladen sehen Sie die Dateiinformationen in der Tabelle auf der Seite „Files“. Sie sehen auch eine CID-Spalte. Sie können die CID kopieren, indem Sie auf die Kopieren-Schaltfläche daneben klicken. Sie können Ihren Upload unter https://gateway.pinata.cloud/ipfs/<CID> ansehen. Das von uns verwendete Bild finden Sie beispielsweise hier (opens in a new tab) auf IPFS.

Für die eher visuellen Lerner sind die obigen Schritte hier zusammengefasst:

Nun möchten wir noch ein weiteres Dokument auf Pinata hochladen. Aber bevor wir das tun, müssen wir es erstellen!

Erstellen Sie in Ihrem Stammverzeichnis eine neue Datei namens nft-metadata.json und fügen Sie den folgenden JSON-Code hinzu:

1{
2  "attributes": [
3    {
4      "trait_type": "Breed",
5      "value": "Maltipoo"
6    },
7    {
8      "trait_type": "Eye color",
9      "value": "Mocha"
10    }
11  ],
12  "description": "The world's most adorable and sensitive pup.",
13  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14  "name": "Ramses"
15}
Alle anzeigen

Sie können die Daten im JSON gerne ändern. Sie können den Abschnitt „attributes“ (Attribute) erweitern oder Einträge daraus entfernen. Am wichtigsten ist, dass das Feld „image“ (Bild) auf den Speicherort Ihres IPFS-Bildes verweist – andernfalls wird Ihr NFT ein Foto eines (sehr süßen!) Hundes enthalten.

Sobald Sie mit der Bearbeitung der JSON-Datei fertig sind, speichern Sie sie und laden Sie sie auf Pinata hoch, indem Sie dieselben Schritte wie beim Hochladen des Bildes befolgen.

Schritt 5: Erstellen Sie eine Instanz Ihres Vertrags

Um nun mit unserem Vertrag zu interagieren, müssen wir eine Instanz davon in unserem Code erstellen. Dazu benötigen wir unsere Vertragsadresse, die wir aus der Bereitstellung oder von Blockscout (opens in a new tab) erhalten können, indem wir nach der Adresse suchen, die Sie zur Bereitstellung des Vertrags verwendet haben.

Im obigen Beispiel lautet unsere Vertragsadresse 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

Als Nächstes verwenden wir die Web3-contract-Methode (opens in a new tab), um unseren Vertrag mithilfe der ABI und der Adresse zu erstellen. Fügen Sie in Ihrer Datei mint-nft.js Folgendes hinzu:

1const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
2
3const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

Schritt 6: Aktualisieren Sie die Datei `.env`

Um nun Transaktionen zu erstellen und an die Ethereum-Chain zu senden, verwenden wir Ihre öffentliche Ethereum-Kontoadresse, um die Konto-Nonce zu erhalten (wird unten erklärt).

Fügen Sie Ihren Public-Key zu Ihrer Datei .env hinzu – wenn Sie Teil 1 des Tutorials abgeschlossen haben, sollte unsere Datei .env nun so aussehen:

1API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
2PRIVATE_KEY = "your-private-account-address"
3PUBLIC_KEY = "your-public-account-address"

Schritt 7: Erstellen Sie Ihre Transaktion

Lassen Sie uns zunächst eine Funktion namens mintNFT(tokenData) definieren und unsere Transaktion erstellen, indem wir Folgendes tun:

Holen Sie sich Ihren PRIVATE_KEY und PUBLIC_KEY aus der Datei .env.
Als Nächstes müssen wir die Konto-Nonce herausfinden. Die Nonce-Spezifikation wird verwendet, um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu verfolgen – was wir aus Sicherheitsgründen und zur Verhinderung von Replay-Angriffen (opens in a new tab) benötigen. Um die Anzahl der von Ihrer Adresse gesendeten Transaktionen zu erhalten, verwenden wir getTransactionCount (opens in a new tab).
Schließlich richten wir unsere Transaktion mit den folgenden Informationen ein:

'from': PUBLIC_KEY — Der Ursprung unserer Transaktion ist unsere öffentliche Adresse
'to': contractAddress — Der Vertrag, mit dem wir interagieren und an den wir die Transaktion senden möchten
'nonce': nonce — Die Konto-Nonce mit der Anzahl der von unserer Adresse gesendeten Transaktionen
'gas': estimatedGas — Das geschätzte Gas, das zum Abschluss der Transaktion benötigt wird
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() — Die Berechnung, die wir in dieser Transaktion durchführen möchten – was in diesem Fall das Prägen eines NFTs ist

Ihre Datei mint-nft.js sollte nun so aussehen:

1   require('dotenv').config();
2   const API_URL = process.env.API_URL;
3   const PUBLIC_KEY = process.env.PUBLIC_KEY;
4   const PRIVATE_KEY = process.env.PRIVATE_KEY;
5
6   const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
7   const web3 = createAlchemyWeb3(API_URL);
8
9   const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
10   const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
11   const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
12
13   async function mintNFT(tokenURI) {
14     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); // neueste Nonce abrufen
15
16   // die Transaktion
17     const tx = {
18       'from': PUBLIC_KEY,
19       'to': contractAddress,
20       'nonce': nonce,
21       'gas': 500000,
22       'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
23     };
24   }
Alle anzeigen

Schritt 8: Signieren Sie die Transaktion

Nachdem wir nun unsere Transaktion erstellt haben, müssen wir sie signieren, um sie abzusenden. Hier verwenden wir unseren Private-Key.

web3.eth.sendSignedTransaction gibt uns den Transaktions-Hash, mit dem wir sicherstellen können, dass unsere Transaktion gemint und nicht vom Netzwerk verworfen wurde. Sie werden feststellen, dass wir im Abschnitt zur Transaktionssignierung eine Fehlerüberprüfung hinzugefügt haben, damit wir wissen, ob unsere Transaktion erfolgreich durchgeführt wurde.

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // neueste Nonce abrufen
15
16  // die Transaktion
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "The hash of your transaction is: ",
34              hash,
35              "\nCheck Alchemy's Mempool to view the status of your transaction!"
36            )
37          } else {
38            console.log(
39              "Something went wrong when submitting your transaction:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log(" Promise failed:", err)
48    })
49}
Alle anzeigen

Schritt 9: Rufen Sie `mintNFT` auf und führen Sie node `mint-nft.js` aus

Erinnern Sie sich an die metadata.json, die Sie auf Pinata hochgeladen haben? Holen Sie sich deren Hashcode von Pinata und übergeben Sie Folgendes als Parameter an die Funktion mintNFT: https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

So erhalten Sie den Hashcode:

Wie man seinen NFT-Metadaten-Hashcode auf Pinata erhält

Überprüfen Sie noch einmal, ob der kopierte Hashcode auf Ihre metadata.json verweist, indem Sie https://gateway.pinata.cloud/ipfs/<metadata-hash-code> in einem separaten Fenster laden. Die Seite sollte ähnlich aussehen wie auf dem Screenshot unten:

Ihre Seite sollte die JSON-Metadaten anzeigen

Insgesamt sollte Ihr Code in etwa so aussehen:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // neueste Nonce abrufen
15
16  // die Transaktion
17  const tx = {
18    from: PUBLIC_KEY,
19    to: contractAddress,
20    nonce: nonce,
21    gas: 500000,
22    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23  }
24
25  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26  signPromise
27    .then((signedTx) => {
28      web3.eth.sendSignedTransaction(
29        signedTx.rawTransaction,
30        function (err, hash) {
31          if (!err) {
32            console.log(
33              "The hash of your transaction is: ",
34              hash,
35              "\nCheck Alchemy's Mempool to view the status of your transaction!"
36            )
37          } else {
38            console.log(
39              "Something went wrong when submitting your transaction:",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log("Promise failed:", err)
48    })
49}
50
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
Alle anzeigen

Führen Sie nun node scripts/mint-nft.js aus, um Ihren NFT bereitzustellen. Nach ein paar Sekunden sollten Sie eine Antwort wie diese in Ihrem Terminal sehen:

The hash of your transaction is: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8

Check Alchemy's Mempool to view the status of your transaction!

Besuchen Sie als Nächstes Ihren Alchemy-Mempool (opens in a new tab), um den Status Ihrer Transaktion zu sehen (ob sie ausstehend ist, gemint wurde oder vom Netzwerk verworfen wurde). Wenn Ihre Transaktion verworfen wurde, ist es auch hilfreich, Blockscout (opens in a new tab) zu überprüfen und nach Ihrem Transaktions-Hash zu suchen.

Ihren NFT-Transaktions-Hash auf Etherscan ansehen

Und das war's! Sie haben nun einen NFT auf der Ethereum-Blockchain bereitgestellt UND geprägt

Mit der mint-nft.js können Sie so viele NFTs prägen, wie Ihr Herz (und Ihre Wallet) begehrt! Stellen Sie nur sicher, dass Sie eine neue tokenURI übergeben, die die Metadaten des NFTs beschreibt (andernfalls erstellen Sie nur einen Haufen identischer NFTs mit unterschiedlichen IDs).

Vermutlich möchten Sie Ihren NFT in Ihrer Wallet präsentieren können – schauen Sie sich also unbedingt Teil 3: Wie Sie Ihren NFT in Ihrer Wallet ansehen an!

Letzte Aktualisierung der Seite: 23. Februar 2026

+20