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 dir, wie du in <10 Minuten dasselbe tun kannst.

Das „Prägen eines NFTs“ ist der Vorgang, eine einzigartige Instanz deines ERC-721-Tokens auf der Blockchain zu veröffentlichen. Unter Verwendung unseres Vertrags aus Teil 1 dieser NFT-Tutorial-Reihe wollen wir unsere Web3-Fähigkeiten unter Beweis stellen und einen NFT prägen. Am Ende dieses Tutorials wirst du in der Lage sein, so viele NFTs zu prägen, wie dein Herz (und deine Wallet) begehrt!

Lass uns anfangen!

Schritt 1: Web3 installieren

Wenn du das erste Tutorial zur Erstellung deines NFT-Vertrags befolgt hast, hast du bereits Erfahrung mit Ethers.js. Web3 ist ähnlich wie Ethers, da es eine Bibliothek ist, 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ühre in deinem Projekt-Stammverzeichnis Folgendes aus:

npm install @alch/alchemy-web3

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

Erstelle in deinem scripts-Verzeichnis eine mint-nft.js-Datei und füge die folgenden Codezeilen hinzu:

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

Schritt 3: Die Vertrags-ABI abrufen

Unsere Vertrags-ABI (Application Binary Interface) ist die Schnittstelle zur Interaktion mit unserem Vertrag. Du kannst mehr über erfahren. 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 auslesen, indem wir die folgenden Codezeilen zu unserer Datei mint-nft.js hinzufügen:

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

Wenn du die ABI sehen möchtest, kannst du sie in deiner Konsole ausgeben:

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

Um mint-nft.js auszuführen und deine ABI in der Konsole ausgeben zu lassen, navigiere zu deinem Terminal und führe Folgendes aus:

node scripts/mint-nft.js

Schritt 4: Die Metadaten für deinen NFT mit IPFS konfigurieren

Wenn du dich an unser Tutorial in Teil 1 erinnerst, nimmt unsere Vertragsfunktion 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 dezentrales 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 dezentral ist. Wenn du noch kein Pinata-Konto hast, melde dich hier (opens in a new tab) für ein kostenloses Konto an und schließe die Schritte zur Verifizierung deiner E-Mail-Adresse ab.

Sobald du ein Konto erstellt hast:

Navigiere zur Seite „Files“ (Dateien) und klicke auf die blaue Schaltfläche „Upload“ (Hochladen) oben links auf der Seite.
Lade ein Bild auf Pinata hoch – dies wird das Bild-Asset für deinen NFT sein. Du kannst das Asset nennen, wie du möchtest.
Nach dem Hochladen siehst du die Dateiinformationen in der Tabelle auf der Seite „Files“. Du siehst auch eine CID-Spalte. Du kannst die CID kopieren, indem du auf die Kopieren-Schaltfläche daneben klickst. Du kannst deinen Upload unter https://gateway.pinata.cloud/ipfs/<CID> ansehen. Das von uns verwendete Bild findest du zum Beispiel hier (opens in a new tab) auf IPFS.

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

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

Erstelle in deinem Stammverzeichnis eine neue Datei namens nft-metadata.json und füge den folgenden JSON-Code hinzu:

{
  "attributes": [
    {
      "trait_type": "Breed",
      "value": "Maltipoo"
    },
    {
      "trait_type": "Eye color",
      "value": "Mocha"
    }
  ],
  "description": "The world's most adorable and sensitive pup.",
  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
  "name": "Ramses"
}

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

Sobald du mit der Bearbeitung der JSON-Datei fertig bist, speichere sie und lade sie auf Pinata hoch, indem du dieselben Schritte wie beim Hochladen des Bildes befolgst.

Schritt 5: Eine Instanz deines Vertrags erstellen

Um nun mit unserem Vertrag zu interagieren, müssen wir in unserem Code eine Instanz davon 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 du zur Bereitstellung des Vertrags verwendet hast.

Im obigen Beispiel lautet unsere Vertragsadresse 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

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

const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"

const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

Schritt 6: Die `.env`-Datei aktualisieren

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

Füge deinen öffentlichen Schlüssel zu deiner .env-Datei hinzu – wenn du Teil 1 des Tutorials abgeschlossen hast, sollte unsere .env-Datei nun so aussehen:

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

Schritt 7: Deine Transaktion erstellen

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

Rufe deinen PRIVATE_KEY und PUBLIC_KEY aus der .env-Datei ab.
Als Nächstes müssen wir die Konto-Nonce herausfinden. Die Nonce-Spezifikation wird verwendet, um die Anzahl der von deiner Adresse gesendeten Transaktionen zu verfolgen – was wir aus Sicherheitsgründen und zur Verhinderung von Replay-Angriffen benötigen. Um die Anzahl der von deiner Adresse gesendeten Transaktionen abzurufen, 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 für den Abschluss der Transaktion benötigt wird
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() – Die Berechnung, die wir in dieser Transaktion ausführen möchten – was in diesem Fall das Prägen eines NFTs ist

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

   require('dotenv').config();
   const API_URL = process.env.API_URL;
   const PUBLIC_KEY = process.env.PUBLIC_KEY;
   const PRIVATE_KEY = process.env.PRIVATE_KEY;

   const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
   const web3 = createAlchemyWeb3(API_URL);

   const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
   const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
   const nftContract = new web3.eth.Contract(contract.abi, contractAddress);

   async function mintNFT(tokenURI) {
     const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //neueste Nonce abrufen

   //die Transaktion
     const tx = {
       'from': PUBLIC_KEY,
       'to': contractAddress,
       'nonce': nonce,
       'gas': 500000,
       'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
     };
   }

Schritt 8: Die Transaktion signieren

Nachdem wir nun unsere Transaktion erstellt haben, müssen wir sie signieren, um sie abzusenden. Hier verwenden wir unseren privaten Schlüssel.

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

require("dotenv").config()
const API_URL = process.env.API_URL
const PUBLIC_KEY = process.env.PUBLIC_KEY
const PRIVATE_KEY = process.env.PRIVATE_KEY

const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)

const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

async function mintNFT(tokenURI) {
  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //neueste Nonce abrufen

  //die Transaktion
  const tx = {
    from: PUBLIC_KEY,
    to: contractAddress,
    nonce: nonce,
    gas: 500000,
    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
  }

  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
  signPromise
    .then((signedTx) => {
      web3.eth.sendSignedTransaction(
        signedTx.rawTransaction,
        function (err, hash) {
          if (!err) {
            console.log(
              "The hash of your transaction is: ",
              hash,
              "\nCheck Alchemy's Mempool to view the status of your transaction!"
            )
          } else {
            console.log(
              "Something went wrong when submitting your transaction:",
              err
            )
          }
        }
      )
    })
    .catch((err) => {
      console.log(" Promise failed:", err)
    })
}

Schritt 9: `mintNFT` aufrufen und node `mint-nft.js` ausführen

Erinnerst du dich an die metadata.json, die du auf Pinata hochgeladen hast? Hole dir ihren Hashcode von Pinata und übergib Folgendes als Parameter an die Funktion mintNFT https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

So erhältst du den Hashcode:

So erhältst du den Hashcode deiner NFT-Metadaten auf Pinata

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

Deine Seite sollte die JSON-Metadaten anzeigen

Insgesamt sollte dein Code in etwa so aussehen:

require("dotenv").config()
const API_URL = process.env.API_URL
const PUBLIC_KEY = process.env.PUBLIC_KEY
const PRIVATE_KEY = process.env.PRIVATE_KEY

const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
const web3 = createAlchemyWeb3(API_URL)

const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

async function mintNFT(tokenURI) {
  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //neueste Nonce abrufen

  //die Transaktion
  const tx = {
    from: PUBLIC_KEY,
    to: contractAddress,
    nonce: nonce,
    gas: 500000,
    data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
  }

  const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
  signPromise
    .then((signedTx) => {
      web3.eth.sendSignedTransaction(
        signedTx.rawTransaction,
        function (err, hash) {
          if (!err) {
            console.log(
              "The hash of your transaction is: ",
              hash,
              "\nCheck Alchemy's Mempool to view the status of your transaction!"
            )
          } else {
            console.log(
              "Something went wrong when submitting your transaction:",
              err
            )
          }
        }
      )
    })
    .catch((err) => {
      console.log("Promise failed:", err)
    })
}

mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")

Führe nun node scripts/mint-nft.js aus, um deinen NFT bereitzustellen. Nach ein paar Sekunden solltest du eine Antwort wie diese in deinem Terminal sehen:

Der Hash deiner Transaktion lautet: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8

Überprüfe den Mempool von Alchemy, um den Status deiner Transaktion einzusehen!

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

Sieh dir deinen NFT-Transaktions-Hash auf Etherscan an

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

Mit der mint-nft.js kannst du so viele NFTs prägen, wie dein Herz (und deine Wallet) begehrt! Achte nur darauf, eine neue tokenURI zu übergeben, die die Metadaten des NFTs beschreibt (andernfalls erstellst du nur einen Haufen identischer NFTs mit unterschiedlichen IDs).

Vermutlich möchtest du deinen NFT auch in deiner Wallet präsentieren können – sieh dir also unbedingt Teil 3: Wie du deinen NFT in deiner Wallet anzeigst an!