Comment écrire et déployer un NFT (Partie 1/3 de la série de tutoriels NFT)

ERC-721

Alchemy

Solidity

contrats intelligents

Débutant

Sumi Mudgil

22 avril 2021

15 minutes de lecture

Grâce aux NFT, la blockchain a été découverte par le grand public. C'est l'occasion rêvée de comprendre cet engouement en publiant votre propre contrat NFT (jeton ERC-721) sur la blockchain Ethereum !

Alchemy est extrêmement fier d'alimenter les plus grands noms de l'espace NFT, y compris Makersplace (qui a récemment établi un record de vente d'œuvres d'art numériques chez Christie's pour 69 millions de dollars), Dapper Labs (créateurs de NBA Top Shot & Crypto Kitties), OpenSea (le plus grand marché NFT du monde), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable, et plus encore.

Dans ce tutoriel, nous allons voir comment créer et déployer un contrat intelligent ERC-721 sur le réseau de test Sepolia en utilisant MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab), Pinata (opens in a new tab) et Alchemy (opens in a new tab) (ne vous inquiétez pas si vous ne comprenez pas encore ce que tout cela signifie, nous allons tout vous expliquer !).

Dans la deuxième partie de ce tutoriel, nous verrons comment utiliser notre contract intelligent pour créer un NFT, et dans la troisième partie, nous expliquerons comment visualiser votre NFT sur MetaMask.

Et bien sûr, si vous avez des questions, n'hésitez pas à les poser sur le Discord d'Alchemy (opens in a new tab) ou à consulter la documentation de l'API NFT d'Alchemy (opens in a new tab) !

Étape 1 : Se connecter au réseau Ethereum

Il existe de nombreuses façons de faire des requêtes à la blockchain Ethereum, mais pour simplifier les choses, nous utiliserons un compte gratuit sur Alchemy (opens in a new tab), une plateforme de développement blockchain et une API qui nous permet de communiquer avec la chaîne Ethereum sans avoir à exécuter nos propres nœuds.

Dans ce tutoriel, nous allons également tirer parti des outils de développement d'Alchemy pour le suivi et l'analyse afin de comprendre ce qui se passe sous le capot concernant le déploiement de notre contract intelligent. Si vous n'avez pas encore de compte Alchemy, vous pouvez vous inscrire gratuitement ici (opens in a new tab).

Étape 2 : Créer votre application (et votre clé API)

Une fois votre compte Alchemy créé, vous pouvez générer une clé API en créant une application. Cela va nous permettre d'émettre des requêtes sur le réseau de test Sepolia. Consultez ce guide (opens in a new tab) si vous souhaitez en savoir plus sur les réseaux de test.

Accédez à la page « Create App » dans votre Tableau de bord Alchemy, en survolant « Apps » dans la barre de navigation et en cliquant sur « Create App »

Nommez votre application (nous avons choisi « Mon premier NFT ! »), donnez une brève description, sélectionnez « Ethereum » pour la chaine, et choisissez « Sepolia » pour votre réseau. Depuis la fusion, les autres réseaux de test sont obsolètes.

Cliquez sur « Create app », et voilà ! Votre application devrait apparaître dans le tableau ci-dessous.

Étape 3 : Créer un compte Ethereum (adresse)

Nous avons besoin d'un compte Ethereum pour effectuer des transactions (envoyer et recevoir). Pour ce tutoriel, nous allons utiliser MetaMask, un portefeuille virtuel intégré au navigateur, servant à gérer les adresses de votre compte Ethereum. Si vous voulez mieux comprendre le fonctionnement des transactions sur Ethereum, consultez cette page de la Fondation Ethereum.

Vous pouvez télécharger et créer un compte MetaMask gratuitement ici (opens in a new tab). Lorsque vous créez un compte, ou si vous en avez déjà un, assurez-vous de basculer sur « Réseau de test Sepolia » en haut à droite (afin de ne pas utiliser d'argent réel).

Étape 4 : Ajouter de l'ether à partir d'un robinet

Afin de déployer notre contrat intelligent sur le serveur test, nous aurons besoin de faux ETH. Pour obtenir des ETH, vous pouvez vous rendre sur le robinet Sepolia (opens in a new tab) hébergé par Alchemy, vous connecter et entrer l'adresse de votre compte, puis cliquer sur « Send Me ETH ». Vous devriez voir votre ETH dans votre compte MetaMask peu de temps après !

Étape 5 : Vérifier votre solde

Pour vérifier que notre solde est bien là, faisons une requête eth_getBalance (opens in a new tab) en utilisant l'outil de composition d'Alchemy (opens in a new tab). Cela va renvoyer la quantité d'ETH dans notre portefeuille. Après avoir entré l'adresse de votre compte MetaMask et cliqué sur « Send Request », vous devriez voir une réponse comme celle-ci :

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

Remarque : ce résultat est en wei, pas en ETH. Le wei est utilisé comme la plus petite dénomination d'ether. La conversion entre wei et ETH est 1 eth = 10¹⁸ wei. Donc si on convertit 0xde0b6b3a7640000 en décimale, nous obtenons 1*10¹⁸ wei, ce qui équivaut à 1 ETH.

Ouf ! Notre faux argent est bien là.

Étape 6 : Initialiser notre projet

Pour commencer, nous allons devoir créer un dossier pour notre projet. Ouvrez votre ligne de commande et tapez :

1mkdir my-nft
2cd my-nft

Maintenant que nous sommes dans le dossier de notre projet, nous allons utiliser npm init pour initialiser le projet. Si vous n'avez pas encore installé npm, suivez ces instructions (opens in a new tab) (nous aurons également besoin de Node.js (opens in a new tab), alors téléchargez-le aussi !).

1npm init

La manière dont vous répondez à ces questions d'installation a peu d'importance ; pour référence, voici comment nous avons répondu :

1    package name: (my-nft)
2    version: (1.0.0)
3    description: Mon premier 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": "Mon premier NFT !",
16      "main": "index.js",
17      "scripts": {
18        "test": "echo \"Error: no test specified\" && exit 1"
19      },
20      "author": "",
21      "license": "ISC"
22    }
Afficher tout

Approuvez le package.json, et nous sommes prêts à démarrer !

Étape 7 : Installer Hardhat (opens in a new tab)

Hardhat est un environnement de développement qui permet de compiler, déployer, tester et déboguer votre logiciel Ethereum. Il aide les développeurs à construire des contrats intelligents et des dApps localement avant de les déployer sur la chaîne en production.

Dans notre projet my-nft, exécutez :

1npm install --save-dev hardhat

Consultez cette page pour plus de détails sur les instructions d'installation (opens in a new tab).

Étape 8 : Créer le projet Hardhat

Dans notre dossier de projet, exécutez :

1npx hardhat

Vous devriez maintenant voir un message de bienvenue ainsi qu'une option pour sélectionner ce que vous voulez faire. Sélectionnez : « create an empty hardhat.config.js » :

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👷 Bienvenue dans Hardhat v2.0.11 👷‍
10? Que voulez-vous faire ? …
11Créer un projet d'exemple
12❯ Créer un fichier hardhat.config.js vide
13Quitter
Afficher tout

Cela va générer un fichier 'hardhar.config.js' dans lequel nous allons spécifier tous les paramètres de notre projet (à l'étape 13).

Étape 9 : Ajouter les dossiers du projet

Pour garder notre projet organisé, nous allons créer deux nouveaux dossiers. Naviguez vers le répertoire racine de votre projet dans votre invite de commande en ligne et tapez :

1mkdir contracts
2mkdir scripts

contracts/ est l'endroit où nous garderons notre code de contrat intelligent NFT
scripts/ est l'endroit où nous garderons les scripts pour déployer et interagir avec notre contrat intelligent

Étape 10 : Écrire notre contrat

Maintenant que notre environnement est configuré, passons à des choses plus passionnantes : l'écriture du code de notre contrat intelligent !

Ouvrez le projet my-nft dans votre éditeur préféré (nous aimons VSCode (opens in a new tab)). Les contrats intelligents sont écrits dans un langage appelé Solidity, qui est celui que nous allons utiliser pour écrire notre contrat intelligent MyNFT.sol.

Allez dans le dossier contracts et créez un nouveau fichier nommé MyNFT.sol

Vous trouverez ci-dessous le code de notre contrat intelligent NFT, que nous avons basé sur l'implémentation ERC-721 de la bibliothèque OpenZeppelin (opens in a new tab). Copiez et collez le contenu ci-dessous dans votre fichier MyNFT.sol.

1// Contrat basé sur [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}
Afficher tout

Puisque nous héritons des classes de la bibliothèque de contrats OpenZeppelin, exécutez npm install @openzeppelin/contracts^4.0.0 dans votre ligne de commande pour installer la bibliothèque dans notre dossier.

Alors, que fait ce code exactement ? Décortiquons-le ligne par ligne.

En haut de notre contrat intelligent, nous importons trois classes de contrats intelligents OpenZeppelin (opens in a new tab) :

@openzeppelin/contracts/token/ERC721/ERC721.sol contient l'implémentation de la norme ERC-721, dont notre contrat intelligent NFT héritera. (Pour être un NFT valide, votre contrat intelligent doit implémenter toutes les méthodes de la norme ERC-721.) Pour en savoir plus sur les fonctions ERC-721 héritées, consultez la définition de l'interface ici (opens in a new tab).
@openzeppelin/contracts/utils/Counters.sol fournit des compteurs qui ne peuvent être incrémentés ou décrémentés que de un. Notre contrat intelligent utilise des compteurs pour garder une trace du nombre total de NFT créés et définir l'ID unique de votre nouveau NFT. (Chaque NFT créé à l'aide d'un contrat intelligent doit se voir attribuer un ID unique - ici notre ID unique est simplement déterminé par le nombre total de NFT existants. Par exemple, le premier NFT que nous créons avec notre contrat intelligent a un ID de « 1 », le deuxième NFT a un ID de « 2 », etc.)
@openzeppelin/contracts/access/Ownable.sol met en place un contrôle d'accès (opens in a new tab) sur notre contrat intelligent, de sorte que seul le propriétaire du contrat intelligent (vous) puisse frapper des NFT. (Remarque : l'inclusion du contrôle d'accès est entièrement une préférence. Si vous souhaitez que n'importe qui puisse créer un NFT en utilisant votre contrat intelligent, supprimez le mot « Ownable » à la ligne 10 et « onlyOwner » à la ligne 17.)

Après nos déclarations d'importation, nous obtenons notre contrat intelligent NFT personnalisé, qui est étonnamment court - il ne contient qu'un compteur, un constructeur et une seule fonction ! C'est grâce à nos contrats OpenZeppelin hérités, qui implémentent la plupart des méthodes dont nous avons besoin pour créer un NFT, comme ownerOf qui renvoie le propriétaire du NFT, et transferFrom, qui transfère la propriété du NFT d'un compte à un autre.

Dans notre constructeur ERC-721, vous remarquerez que nous passons deux chaînes de caractères, « MyNFT » et « NFT ». La première variable est le nom de notre contrat intelligent, et le second est son symbole. Vous pouvez nommer chacune de ces variables comme vous le souhaitez !

Enfin, nous avons notre fonction mintNFT(address recipient, string memory tokenURI) qui nous permet de frapper un NFT ! Vous remarquerez que cette fonction prend en paramètre deux variables :

address recipient spécifie l'adresse qui recevra votre NFT fraîchement frappé.
string memory tokenURI est une chaîne de caractères qui doit correspondre à un document JSON décrivant les métadonnées du NFT. Les métadonnées d'un NFT sont ce qui lui donne vie, lui permettant d'avoir des propriétés configurables, comme un nom, une description, une image et d'autres attributs. Dans la deuxième partie de ce tutoriel, nous décrirons comment configurer ces métadonnées.

mintNFT appelle certaines méthodes de la bibliothèque ERC-721 héritée, et renvoie finalement un nombre qui représente l'ID du NFT fraîchement frappé.

Étape 11 : Connecter MetaMask et Alchemy à votre projet

Maintenant que nous avons créé un portefeuille MetaMask, un compte Alchemy et écrit notre contrat intelligent, il est temps de connecter les trois.

Chaque transaction envoyée depuis votre portefeuille virtuel nécessite une signature en utilisant votre clé privée unique. Pour donner cette permission à notre programme, nous pouvons stocker en toute sécurité notre clé privée (et la clé API Alchemy) dans un fichier d'environnement.

Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur l'envoi de transactions à l'aide de web3.

Premièrement, installez le paquet dotenv dans votre dossier de projet :

1npm install dotenv --save

Ensuite, créez un fichier .env à la racine de notre projet, et ajoutez-y votre clé privée MetaMask et votre URL d'API HTTP Alchemy.

Suivez ces instructions (opens in a new tab) pour exporter votre clé privée depuis MetaMask.
Voir ci-dessous pour obtenir l'URL de l'API HTTP Alchemy et la copier dans votre presse-papiers

Votre fichier .env devrait maintenant ressembler à ceci :

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

Pour les relier effectivement à notre code, nous ferons référence à ces variables dans notre fichier hardhat.config.js à l'étape 13.

Ne pas exécuter l'.env! Il est vivement déconseillé d'exposer ses données personnelles figurant dans ce fichier.env ou de les partager avec d'autres personnes, car cela pourrait compromette la confidentialité de vos données personnelles. Si vous utilisez déjà un modèle de sécurité rigide, ajoutez votre.env au fichier gitignore.

Étape 12 : Installer Ethers.js

Ethers.js est une bibliothèque qui facilite l'interaction et l'envoi de requêtes à Ethereum en encapsulant les méthodes JSON-RPC standard dans des méthodes plus conviviales.

Hardhat facilite grandement l'intégration de plugins (opens in a new tab) pour des outils supplémentaires et des fonctionnalités étendues. Nous allons profiter du plugin Ethers (opens in a new tab) pour le déploiement du contrat (Ethers.js (opens in a new tab) a des méthodes de déploiement de contrat très propres).

Dans votre dossier de projet, tapez :

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

Nous aurons également besoin d'ethers dans notre hardhat.config.js à l'étape suivante.

Étape 13 : Mettre à jour hardhat.config.js

À ce stade, nous avons ajouté plusieurs dépendances et plugins. Nous devons maintenant mettre à jour hardhat.config.js pour que notre projet les reconnaisse.

Mettez à jour votre hardhat.config.js pour qu'il ressemble à ceci :

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    }
Afficher tout

Étape 14 : Compiler notre contrat

Pour s’assurer à ce stade que tout fonctionne, compilons notre contrat. La tâche « compile » est une des tâches intégrée à hardhat.

À partir de la ligne de commande, exécutez :

1npx hardhat compile

Vous pourriez voir un avertissement du type « SPDX license identifier not provided in source file » (identifiant de licence SDPX non fourni dans le fichier source), mais nul besoin de vous inquiéter — espérons que tout le reste fonctionne ! Sinon, vous pouvez toujours envoyer un message sur le Discord d'Alchemy (opens in a new tab).

Étape 15 : Écrire notre script de déploiement

Maintenant que notre contrat est codé et que notre fichier de configuration est bon, il est temps d’écrire notre script de déploiement pour notre contrat.

Allez dans le dossier scripts/, créez un nouveau fichier nommé deploy.js et ajoutez-y le contenu suivant :

1async function main() {
2  const MyNFT = await ethers.getContractFactory("MyNFT")
3
4  // Démarrer le déploiement, en retournant une promesse qui se résout en un objet de contrat
5  const myNFT = await MyNFT.deploy()
6  await myNFT.deployed()
7  console.log("Contrat déployé à l'adresse :", myNFT.address)
8}
9
10main()
11  .then(() => process.exit(0))
12  .catch((error) => {
13    console.error(error)
14    process.exit(1)
15  })
Afficher tout

Hardhat explique très bien ce que fait chacune de ces lignes de code dans son tutoriel sur les contrats (opens in a new tab), nous avons repris leurs explications ici.

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

Un ContractFactory dans ethers.js est une abstraction utilisée pour déployer de nouveaux contrats intelligents, donc MyNFT est ici une usine pour les instances de notre contrat NFT. Lors de l'utilisation du plugin « hardhat-ethers », les instances de ContractFactory et de Contract sont connectées au premier signataire par défaut.

1const myNFT = await MyNFT.deploy();

L'appel de deploy() sur un ContractFactory lancera le déploiement, et renverra une « Promise » qui se résout en un Contrat. C'est l'objet qui possède une méthode pour chacune des fonctions de notre contrat intelligent.

Étape 16 : Déployer notre contrat

Nous sommes enfin prêts à déployer notre contrat intelligent ! Naviguez à nouveau vers la racine du répertoire de votre projet, et dans la ligne de commande, exécutez :

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

Vous devriez maintenant voir quelque chose comme :

1Contrat déployé à l'adresse : 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

Si nous allons sur l'Etherscan de Sepolia (opens in a new tab) et que nous recherchons l'adresse de notre contrat, nous devrions pouvoir voir qu'il a été déployé avec succès. Si vous ne pouvez pas le voir immédiatement, veuillez patienter, car cela peut prendre un certain temps. La transaction ressemblera à quelque chose comme :

L'adresse de l'expéditeur (From) doit correspondre à l'adresse de votre compte MetaMask et l'adresse du destinataire (To) indiquera « Création de contrat ». Si nous cliquons sur la transaction, nous verrons l'adresse de notre contrat dans le champ « To » :

Super ! Vous venez de déployer votre contrat intelligent NFT sur la chaîne (réseau de test) d'Ethereum !

Pour comprendre ce qui se passe en coulisses, allons dans l'onglet Explorer de notre tableau de bord Alchemy (opens in a new tab). Si vous avez plusieurs applications Alchemy, veillez à filtrer par application et à sélectionner « MyNFT ».

Vous verrez ici un certain nombre d'appels JSON-RPC qu'Hardhat/Ethers ont effectué sous le capot pour nous lorsque nous avons appelé la fonction .deploy(). Deux appels importants à signaler ici sont eth_sendRawTransaction, qui est la requête pour effectivement écrire notre contrat intelligent sur la chaîne Sepolia, et eth_getTransactionByHash qui est une requête pour lire des informations sur notre transaction à partir de son hachage (un modèle typique lors de l'envoi de transactions). Pour en savoir plus sur l'envoi de transactions, consultez ce tutoriel sur l'envoi de transactions à l'aide de Web3.

C'est tout pour la Partie 1 de ce tutoriel. Dans la partie 2, nous interagirons avec notre contrat intelligent en frappant un NFT, et dans la partie 3, nous vous montrerons comment voir votre NFT dans votre portefeuille Ethereum !

Dernière mise à jour de la page : 5 décembre 2025