Comment frapper un NFT (partie 2/3 de la série de tutoriels sur les NFT)

ERC-721

Alchemy

Solidity

contrats intelligents

Débutant

Sumi Mudgil

22 avril 2021

10 minutes de lecture

Beeple (opens in a new tab) : 69 millions de dollars 3LAU (opens in a new tab) : 11 millions de dollars Grimes (opens in a new tab) : 6 millions de dollars

Tous ont frappé leurs NFT en utilisant la puissante API d'Alchemy. Dans ce tutoriel, nous vous apprendrons comment faire la même chose en <10 minutes.

« Frapper un NFT » est l'acte de publier une instance unique de votre jeton ERC-721 sur la blockchain. En utilisant notre contrat intelligent de la partie 1 de cette série de tutoriels sur les NFT, mettons en pratique nos compétences Web3 et frappons un NFT. À la fin de ce tutoriel, vous serez en mesure de frapper autant de NFT que votre cœur (et votre portefeuille) le désire !

Commençons !

Étape 1 : Installer Web3

Si vous avez suivi le premier tutoriel sur la création de votre contrat intelligent de NFT, vous avez déjà de l'expérience avec Ethers.js. Web3 est similaire à Ethers, car c'est une bibliothèque utilisée pour faciliter la création de requêtes sur la blockchain Ethereum. Dans ce tutoriel, nous utiliserons Alchemy Web3 (opens in a new tab), qui est une bibliothèque Web3 améliorée offrant des relances automatiques et une prise en charge robuste de WebSocket.

Dans le répertoire principal de votre projet, exécutez :

1npm install @alch/alchemy-web3

Étape 2 : Créer un fichier `mint-nft.js`

Dans votre répertoire scripts, créez un fichier mint-nft.js et ajoutez les lignes de code suivantes :

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

Étape 3 : Récupérer l'ABI de votre contrat

L'ABI (Application Binary Interface) de notre contrat est l’interface qui permet d'interagir avec notre contrat intelligent. Vous pouvez en apprendre davantage sur les ABI de contrat ici (opens in a new tab). Hardhat génère automatiquement un ABI pour nous et l'enregistre dans le fichier MyNFT.json. Pour l'utiliser, nous devrons analyser le contenu en ajoutant les lignes de code suivantes à notre fichier mint-nft.js :

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

Si vous voulez voir l'ABI, vous pouvez l'afficher dans votre console :

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

Pour exécuter mint-nft.js et voir votre ABI s'afficher dans la console, allez dans votre terminal et exécutez :

1node scripts/mint-nft.js

Étape 4 : Configurer les métadonnées pour votre NFT à l'aide d'IPFS

Si vous vous souvenez de notre tutoriel de la partie 1, notre fonction de contrat intelligent mintNFT prend en entrée un paramètre tokenURI qui doit correspondre à un document JSON décrivant les métadonnées du NFT — c'est vraiment ce qui donne vie au NFT, lui permettant d'avoir des propriétés configurables, telles qu'un nom, une description, une image et d'autres attributs.

Interplanetary File System (IPFS) est un protocole décentralisé et un réseau pair-à-pair pour le stockage et le partage de données dans un système de fichiers distribué.

Nous utiliserons Pinata, une API IPFS et une boîte à outils pratiques, pour stocker notre actif NFT et ses métadonnées afin de garantir que notre NFT est véritablement décentralisé. Si vous n'avez pas de compte Pinata, créez-en un gratuitement ici (opens in a new tab) et suivez les étapes pour vérifier votre e-mail.

Une fois votre compte créé :

Rendez-vous sur la page « Files » et cliquez sur le bouton bleu « Upload » en haut à gauche de la page.
Téléversez une image sur Pinata — ce sera l'image de votre NFT. N’hésitez pas à nommer l'actif comme vous le souhaitez
Après le téléversement, vous verrez les informations du fichier dans le tableau de la page « Files ». Vous verrez également une colonne CID. Vous pouvez copier le CID en cliquant sur le bouton de copie situé à côté. Vous pouvez voir votre téléversement à l'adresse suivante : https://gateway.pinata.cloud/ipfs/<CID>. Vous pouvez par exemple trouver l'image que nous avons utilisée sur IPFS ici (opens in a new tab).

Pour les personnes qui préfèrent un support visuel, les étapes ci-dessus sont résumées ici :

Maintenant, nous allons téléverser un document de plus sur Pinata. Mais avant cela, nous devons le créer !

Dans votre répertoire racine, créez un nouveau fichier nommé nft-metadata.json et ajoutez-y le code JSON suivant :

1{
2  "attributes": [
3    {
4      "trait_type": "Race",
5      "value": "Maltipoo"
6    },
7    {
8      "trait_type": "Couleur des yeux",
9      "value": "Moka"
10    }
11  ],
12  "description": "Le chiot le plus adorable et le plus sensible du monde.",
13  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14  "name": "Ramses"
15}
Afficher tout

N'hésitez pas à modifier les données dans le fichier JSON. Vous pouvez supprimer ou ajouter des éléments dans la section des attributs. Plus important encore, assurez-vous que le champ de l'image pointe vers l'emplacement de votre image IPFS — sinon, votre NFT inclura une photo d'un (très mignon !) chien.

Une fois que vous avez fini de modifier le fichier JSON, enregistrez-le et téléversez-le sur Pinata, en suivant les mêmes étapes que pour l'image.

Étape 5 : Créer une instance de votre contrat

Maintenant, pour interagir avec notre contrat, nous devons en créer une instance dans notre code. Pour ce faire, nous aurons besoin de l'adresse de notre contrat, que nous pouvons obtenir à partir du déploiement ou de Blockscout (opens in a new tab) en consultant l'adresse que vous avez utilisée pour déployer le contrat.

Dans l'exemple ci-dessus, l'adresse de notre contrat est 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

Ensuite, nous utiliserons la méthode de contrat (opens in a new tab) Web3 pour créer notre contrat à l'aide de l'ABI et de l'adresse. Dans votre fichier mint-nft.js, ajoutez ce qui suit :

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

Étape 6 : Mettre à jour le fichier `.env`

Maintenant, pour créer et envoyer des transactions vers la chaîne Ethereum, nous utiliserons l'adresse de votre compte public Ethereum pour obtenir le nonce du compte (nous l'expliquerons ci-dessous).

Ajoutez votre clé publique à votre fichier .env — si vous avez terminé la partie 1 du tutoriel, votre fichier .env devrait maintenant ressembler à ceci :

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

Étape 7 : Créer votre transaction

Tout d'abord, nous allons définir une fonction nommée mintNFT(tokenData) et créer notre transaction en procédant comme suit :

Récupérez vos PRIVATE_KEY et PUBLIC_KEY depuis le fichier .env.
Ensuite, nous devrons déterminer le nonce du compte. La spécification de nonce est utilisée pour suivre le nombre de transactions envoyées depuis votre adresse. Nous en avons besoin pour des raisons de sécurité et pour empêcher les attaques par rejeu (opens in a new tab). Pour obtenir le nombre de transactions envoyées depuis votre adresse, nous utilisons getTransactionCount (opens in a new tab).
Enfin, nous allons configurer notre transaction avec les informations suivantes :

'from': PUBLIC_KEY — L'origine de notre transaction est notre adresse publique.
'to': contractAddress — Le contrat avec lequel nous souhaitons interagir et auquel nous souhaitons envoyer la transaction.
'nonce': nonce — Le nonce du compte, avec le nombre de transactions envoyées depuis notre adresse.
'gas': estimatedGas — La quantité de gaz estimée nécessaire pour effectuer la transaction.
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() — Le calcul que nous souhaitons effectuer dans cette transaction, qui est dans ce cas le frappage d'un NFT.

Votre fichier mint-nft.js devrait maintenant ressembler à ceci :

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'); //obtenir le dernier nonce
15
16   //la transaction
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   }
Afficher tout

Étape 8 : Signer la transaction

Maintenant que nous avons créé notre transaction, nous devons la signer pour pouvoir l'envoyer. C'est ici que nous allons utiliser notre clé privée.

web3.eth.sendSignedTransaction nous donnera le hachage de la transaction, que nous pourrons utiliser pour nous assurer que notre transaction a été minée et n'a pas été abandonnée par le réseau. Vous remarquerez que dans la section de signature de la transaction, nous avons ajouté une vérification des erreurs afin de savoir si notre transaction a été effectuée avec succès.

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") //obtenir le dernier nonce
15
16  //la transaction
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              "Le hachage de votre transaction est : ",
34              hash,
35              "\nConsultez le Mempool d'Alchemy pour voir l'état de votre transaction !"
36            )
37          } else {
38            console.log(
39              "Un problème est survenu lors de l'envoi de votre transaction :",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log(" La promesse a échoué :", err)
48    })
49}
Afficher tout

Étape 9 : Appeler `mintNFT` et exécuter `node mint-nft.js`

Vous vous souvenez du fichier metadata.json que vous avez téléversé sur Pinata ? Obtenez son code de hachage sur Pinata et transmettez ce qui suit comme paramètre à la fonction mintNFT : https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

Voici comment obtenir le code de hachage :

Comment obtenir le code de hachage des métadonnées de votre NFT sur Pinata

Vérifiez que le code de hachage que vous avez copié renvoie bien à votre metadata.json en chargeant https://gateway.pinata.cloud/ipfs/<metadata-hash-code> dans une fenêtre distincte. La page devrait ressembler à la capture d'écran ci-dessous :

Votre page devrait afficher les métadonnées JSON

Au final, votre code devrait ressembler à ceci :

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") //obtenir le dernier nonce
15
16  //la transaction
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              "Le hachage de votre transaction est : ",
34              hash,
35              "\nConsultez le Mempool d'Alchemy pour voir l'état de votre transaction !"
36            )
37          } else {
38            console.log(
39              "Un problème est survenu lors de l'envoi de votre transaction :",
40              err
41            )
42          }
43        }
44      )
45    })
46    .catch((err) => {
47      console.log("La promesse a échoué :", err)
48    })
49}
50
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
Afficher tout

Maintenant, exécutez node scripts/mint-nft.js pour déployer votre NFT. Après quelques secondes, vous devriez voir une réponse comme celle-ci dans votre terminal :

1Le hachage de votre transaction est : 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
2
3Consultez le Mempool d'Alchemy pour voir l'état de votre transaction !

Ensuite, visitez le mempool d'Alchemy (opens in a new tab) pour voir l'état de votre transaction (si elle est en attente, minée ou abandonnée par le réseau). Si votre transaction a été abandonnée, il est également utile de consulter Blockscout (opens in a new tab) et de rechercher le hachage de votre transaction.

Afficher le hachage de votre transaction NFT sur Etherscan

Et c'est tout ! Vous avez maintenant déployé ET frappé un NFT sur la blockchain Ethereum

Avec mint-nft.js, vous pouvez frapper autant de NFT que votre cœur (et votre portefeuille) le désire ! Veillez simplement à transmettre une nouvelle URI de jeton décrivant les métadonnées du NFT (sinon, vous finirez par en créer un tas d'identiques avec des ID différents).

Vous aimeriez probablement pouvoir montrer votre NFT dans votre portefeuille — alors ne manquez pas de consulter la Partie 3 : Comment afficher votre NFT dans votre portefeuille !

Dernière mise à jour de la page : 23 février 2026