Passer au contenu principal

Comment créer et déployer un ERC-721 (NFT)

Mis à jour le
26 novembre 2025
Profil de Sahil Sen
Sahil Sen
Ethereum
IPFS
Produit Quicknode
Remix.IDE
Solidité
JavaScript
NFT
Vidéo

12 minutes de lecture

Aperçu​

Les objets de collection numériques compatibles avec la norme ERC-721 ont connu un grand succès depuis le lancement de Cryptokitties et ont franchi une nouvelle étape vers leur adoption massive ces derniers mois. Ce guide explique comment créer et déployer un NFT (ERC-721) à l'aide de la norme OpenZeppelin.

Vous préférez un tutoriel vidéo ? Suivez Radek et découvrez comment créer et déployer un ERC-721 (NFT) en 20 minutes.
Abonnez-vous à notre chaîne YouTube pour découvrir d'autres vidéos !

Ce que vous ferez​


  • Découvrez les jetons non fongibles (NFT) et leurs cas d'utilisation
  • Créez les métadonnées du jeton ERC-721 que vous allez développer
  • Téléchargez vos fichiers sur un système de stockage décentralisé (IPFS)
  • Créer et déployer un jeton ERC-721 à l'aide de Remix.IDE

Ce dont vous aurez besoin​


  • Un point de terminaison Quicknode (vous pouvez en créer un gratuitement ici)
  • Un portefeuille Web3 (par exemple, MetaMask, Coinbase Wallet, Phantom ou un portefeuille compatible avec WalletConnect) contenant de l'ETH de test (vous pouvez en obtenir via le robinet Multi-Chain Quicknode)
  • IPFS CLI installé
  • Un navigateur Web moderne (par exemple, Chrome)

Qu'est-ce qu'un jeton non fongible ?​

Le terme « fongible » signifie « identique » ou « interchangeable ». Par exemple, les jetons Ethereum, qui appartiennent tous à une même catégorie, ont tous la même valeur. Il en va de même pour les jetons Cardano. Les jetons fongibles sont interchangeables à raison de 1 pour 1.

Dans cette optique, les NFT sont uniques ; chacun d’entre eux est différent. Chaque jeton possède des caractéristiques et une valeur qui lui sont propres. Les objets pouvant faire l’objet d’un NFT sont, par exemple, des cartes à collectionner, des œuvres d’art, des billets d’avion, etc. Ils se distinguent tous clairement les uns des autres et ne sont pas interchangeables. Considérez les jetons non fongibles (NFT) comme des objets de collection rares ; chacun possède des caractéristiques uniques, des attributs particuliers et, la plupart du temps, ses propres métadonnées.

Qu'est-ce que l'ERC-721 ?​

ERC signifie « Ethereum Request for Comment » (appel à commentaires Ethereum), et 721 correspond au numéro d'identification de la proposition. Les ERC sont des normes au niveau applicatif au sein de l'écosystème Ethereum ; il peut s'agir, par exemple, d'une norme de contrat intelligent pour les jetons telle que l'ERC-20. L'auteur d'un ERC est chargé d'établir un consensus au sein de la communauté Ethereum, et une fois que la proposition a été examinée et approuvée par la communauté, elle devient une norme. Vous pouvez suivre les dernières propositions ERC ici. L'ERC-721 a été créé afin de proposer une fonctionnalité permettant de suivre et de transférer des NFT au sein de contrats intelligents.

ERC-721 est une norme ouverte qui décrit comment créer des jetons non fongibles (NFT) sur des blockchains compatibles avec l'EVM (Ethereum Virtual Machine) ; il s'agit d'une interface standard pour les jetons non fongibles ; elle définit un ensemble de règles qui facilitent l'utilisation des NFT. Les NFT ne sont pas uniquement de type ERC-721 ; ils peuvent également être des jetons ERC-1155.

Voici l'ensemble des fonctions et des événements définis dans la norme ERC-721 :

Fonctions ERC-721​

balanceOf: cette fonction permet de renvoyer le nombre de NFT (jetons non fongibles) détenus par une adresse spécifique.

ownerOf: Cette fonction renvoie l'adresse du propriétaire d'un jeton spécifique. Chaque jeton ERC721 est unique et représenté par un identifiant. Cette fonction permet aux utilisateurs ou aux applications d'identifier le propriétaire du jeton à partir de son identifiant unique.

safeTransferFrom (sans données) : cette fonction transfère en toute sécurité la propriété d'un jeton spécifique d'une adresse à une autre. Elle vérifie si le destinataire est un contrat intelligent. Si c'est le cas, celui-ci doit implémenter une fonction spécifique (onERC721Received) pour accepter le transfert.

transferFrom: cette fonction sert à transférer la propriété d'un jeton d'une adresse à une autre. Elle est généralement utilisée lorsque l'expéditeur a reçu l'autorisation de transférer le jeton.

approuver: cette fonction sert à autoriser une adresse à transférer un token spécifique. Elle permet d'effectuer des transferts par délégation, c'est-à-dire qu'un propriétaire peut autoriser une autre partie à transférer un token en son nom.

getApproved: cette fonction permet d'obtenir l'adresse approuvée pour un jeton spécifique. S'il n'existe aucune adresse approuvée pour ce jeton, cette fonction renvoie une adresse nulle.

setApprovalForAll: cette fonction permet au détenteur d'un ou plusieurs jetons d'autoriser ou de révoquer l'autorisation accordée à un opérateur de gérer l'ensemble de ses jetons.

isApprovedForAll: cette fonction permet de vérifier si un opérateur est autorisé à gérer l'ensemble des jetons d'un propriétaire.

safeTransferFrom (avec données) : cette fonction est similaire à safeTransferFrom (sans données), mais comporte un paramètre de données supplémentaire. Ces données supplémentaires peuvent être utilisées pour transmettre des informations complémentaires lors du transfert si le destinataire est un contrat intelligent. Cette fonction vérifie également si le destinataire est un contrat intelligent et s’il implémente la fonction onERC721Received.

Événements ERC-721​

Transfert: cet événement est déclenché lorsque la propriété d'un jeton passe d'une adresse à une autre. Il contient des informations sur l'expéditeur (from), le destinataire (to) et le jeton spécifique (par ID) qui a été transféré. Cet événement permet à des écouteurs externes, tels que des interfaces utilisateur ou d'autres contrats, de réagir au transfert.

Approbation: cet événement est déclenché lorsqu'une adresse est autorisée à transférer un jeton spécifique. Il inclut le propriétaire actuel du jeton (owner), l'adresse autorisée qui peut désormais transférer le jeton (approved) et le jeton spécifique (par ID) dont le transfert a été approuvé. Cet événement permet aux applications de suivre les autorisations de transfert de jetons et de réagir en conséquence.

ApprovalForAll: Cet événement est déclenché lorsqu'un propriétaire approuve ou révoque l'autorisation accordée à un opérateur de gérer l'ensemble de ses jetons. Il comprend l'adresse du propriétaire (owner), celle de l'opérateur (operator) et une valeur booléenne indiquant si l'opérateur a été approuvé ou non (approved). Cet événement permet aux applications de savoir quelles adresses ont reçu l'autorisation de gérer l'ensemble des jetons d'un propriétaire donné.

Cas d'utilisation des jetons non fongibles (NFT)​

  • Art numérique (ou art physique) : les œuvres d'art constituent les cas d'utilisation les plus courants des NFT. Les ventes aux enchères d'art numérique ont été la première application des NFT et continuent de se développer.

  • Jeux vidéo : proposer des achats intégrés et des objets de collection dans les jeux.

  • Immobilier : tokenisation des biens immobiliers, contrats intelligents et opérations d'achat et de vente.

  • Finance : instruments financiers tels que les prêts, les contrats à terme et autres engagements.

  • Logiciels : licences logicielles visant à lutter contre le piratage et à garantir la protection de la vie privée.

  • Billets de concert / Billets de matchs sportifs : afin de garantir l'absence de fraude dans la vente de billets et de permettre aux fans de disposer d'un espace unique où consulter l'historique de leurs expériences.

  • Conformité KYC : création d'un jeton pour la procédure KYC d'un utilisateur spécifique.

Obtenir de l'ETH de test​

Maintenant que nous savons ce que sont les jetons ERC-721 et comment ils fonctionnent, voyons comment nous pouvons créer et déployer nos propres jetons.

Nous allons déployer notre contrat sur le testnet Sepolia d’Ethereum. Pour commencer, vous aurez besoin de l’extension de navigateur MetaMask (ou d’un autre portefeuille web3 compatible, tel que Phantom ou un portefeuille compatible avec WalletConnect) et d’un peu d’ETH de test, que vous pouvez obtenir en vous rendant sur le site Quicknode Multi-Chain Faucet. Il vous suffit de connecter votre portefeuille ou de coller l’adresse, puis de cliquer sur « Continuer ». Il vous sera demandé de partager un tweet pour obtenir un bonus (nous vous le recommandons !) ; sinon, cliquez simplement sur « Non merci, envoyez-moi juste 0,05 ETH ». Notez qu’un solde minimum de 0,001 ETH est requis sur le réseau principal Ethereum pour utiliser les robinets EVM.

Chaîne multi-robinets Quicknode

Ajouter des fichiers à IPFS​

Avant de rédiger notre contrat NFT, nous devons héberger notre œuvre d'art destinée à devenir un NFT et créer un fichier de métadonnées ; pour cela, nous utiliserons IPFS, un système distribué de stockage et de partage de fichiers en peer-to-peer. Il existe plusieurs façons d’interagir avec le protocole IPFS. Vous pouvez soit configurer et exploiter IPFS sur votre propre système, soit opter pour Quicknode, une solution plus simple. Quicknode simplifie votre accès à IPFS en gérant l’infrastructure sous-jacente. Cette approche vous permet de vous concentrer sur votre contenu, en vous déchargeant des responsabilités liées à la maintenance d’un nœud IPFS local pour l’ancrage des données. Avec Quicknode, les complexités techniques sont gérées à votre place.

Nous vous présentons deux méthodes pour mettre vos fichiers en ligne sur IPFS : via l'interface CLI standard d'IPFS ou via le service simplifié Quicknode IPFS.

Méthode standard : utilisation de l'interface CLI d'IPFS​

Téléchargez et installez l'interface CLI d'IPFS adaptée à votre système d'exploitation en suivant le guide d'installation disponible dans la documentation d'IPFS.

Voici les étapes à suivre pour mettre en ligne l'image et le fichier de métadonnées.

Étape 1 : Création d'un dépôt IPFS​

Lancez le dépôt IPFS en saisissant la commande suivante dans une fenêtre de terminal ou de commande.

ipfs init

Étape 2 : Démarrage du démon IPFS​

Lancez le démon IPFS, ouvrez une fenêtre de terminal ou de commande distincte, puis saisissez la commande suivante.

démon IPFS

Étape 3 : Ajouter une image sur IPFS​

Ouvrez la première fenêtre de terminal et ajoutez l'image à IPFS (ici : art.png).

ipfs add art.png

Métadonnées des œuvres d'art NFT

Copiez le hachage commençant par « Qm » et ajoutez-y le préfixe «https://ipfs.io/ipfs/» ; il doit ressembler à ceci : https://ipfs.io/ipfs/QmQEVVLJUR1WLN15S49rzDJsSP7za9DxeqpUzWuG4aondg

Étape 4 : Ajouter un fichier JSON à IPFS​

Créez un fichier JSON nommé « nft.json » et enregistrez-le dans le même répertoire que l'image.

Format de fichier JSON :

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

Maintenant, ajoutez le fichier JSON.

ipfs add nft.json

Prenez le hachage commençant par « Qm » et ajoutez-lui le préfixe «https://ipfs.io/ipfs/ »; il devrait ressembler à ceci : https://ipfs.io/ipfs/QmUFbUjAifv9GwJo7ufTB5sccnrNqELhDMafoEmZdPPng7

Enregistrez cette URL. Nous en aurons besoin pour créer notre NFT.

Solution IPFS Quicknode : une alternative plus simple​

informations

Pour en savoir plus sur les tarifs de Quicknode IPFS, consultez nos formules tarifaires ici.

Si vous recherchez une approche plus simple, le service IPFS de Quicknode offre une solution efficace et facile à utiliser pour mettre en ligne vos actifs NFT. Avec Quicknode, la gestion complexe de l'infrastructure est prise en charge, ce qui vous permet de vous concentrer sur votre contenu plutôt que sur la maintenance d'un nœud IPFS local.

Pour commencer à utiliser Quicknode avec IPFS, procédez comme suit :

Étape 1 : Se connecter à Quicknode​

Connectez-vous à Quicknode et sélectionnez l'option IPFS dans la barre latérale de gauche :

Présentation d'IPFS sur Quicknode

Étape 2 : Ajouter une image sur IPFS avec Quicknode​

Importez rapidement votre fichier image par glisser-déposer ou en cliquant pour sélectionner des fichiers dans la fenêtre du Finder/de l'Explorateur de fichiers. Dans ce guide, nous utilisons l'image ci-dessous.

Métadonnées des œuvres d'art NFT

Une fois le fichier téléchargé, cliquez sur son nom dans l'onglet « Fichiers », puis cliquez sur le bouton « Copier l'URL IPFS ». Comme le montre la capture d'écran ci-dessous.

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

Image sur le tableau de bord IPFS de Quicknode

Étape 3 : Ajouter un fichier JSON à IPFS avec Quicknode​

Créez un fichier JSON nommé nft.json, remplacez votre URL IPFS dans le image champ, puis enregistrez-le. Une fois l'enregistrement effectué, téléversez votre fichier JSON sur IPFS, comme à l'étape précédente.

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

Une fois le fichier téléchargé, cliquez sur son nom dans l'onglet « Fichiers » et copiez l'URL IPFS. Elle doit ressembler à celle ci-dessous.

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

Enregistrez cette URL. Nous en aurons besoin pour créer notre NFT.

Créer notre propre jeton​

Pour plus de simplicité et de sécurité, nous utiliserons le contrat ERC-721 d'OpenZeppelin pour créer notre NFT. Grâce à OpenZeppelin, nous n'avons pas besoin d'écrire l'intégralité de l'interface ERC-721. Nous pouvons simplement importer le contrat de la bibliothèque et utiliser ses fonctions.

Rendez-vous sur l'IDE Ethereum Remix et créez un nouveau fichier Solidity, par exemple : MyToken.sol

Collez le code suivant dans votre nouveau script Solidity :

// 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);
    }
}

Explication du code ci-dessus :

Ligne 1 : Spécification du type de licence SPDX comme étant « MIT ». Cela indique que le code est soumis à la licence MIT, une licence open source permissive qui autorise l'utilisation, la modification et la distribution du code avec très peu de restrictions.

Ligne 2 : Déclaration de la version de Solidity comme étant ^0.8.20. Cela indique que le code est écrit en utilisant la version 0.8.20 de Solidity ou une version compatible.

Lignes 4 à 7 : Importation des contrats nécessaires depuis la bibliothèque OpenZeppelin.

  • ERC721.sol : ce contrat est importé depuis la bibliothèque OpenZeppelin et constitue l'implémentation de base de la norme ERC721. La norme ERC721 est la norme relative aux jetons non fongibles (NFT).

  • ERC721URIStorage.sol : ce contrat étend le standard ERC721 et ajoute des fonctionnalités permettant de stocker et de gérer les URI de métadonnées associées aux NFT. Les URI de métadonnées renvoient généralement vers des informations supplémentaires concernant le NFT.

  • ERC721Burnable.sol : ce contrat étend également la norme ERC721 et ajoute la possibilité de « brûler » (détruire) des NFT. Il fournit une fonction permettant de retirer définitivement des NFT de la circulation, et seul leur propriétaire peut l'invoquer.

  • Ownable.sol : ce contrat sert au contrôle d'accès. Il permet de désigner un propriétaire bénéficiant de privilèges spéciaux au sein du contrat. Le propriétaire peut effectuer certaines actions que les autres utilisateurs ne peuvent pas effectuer.

Ligne 9 : Lancement du contrat nommé MyToken et en précisant qu'il étend les contrats ERC721, ERC721URIStorage et Ownable. Cela signifie que le MyToken Le contrat hérite des fonctionnalités et des propriétés définies dans ces contrats.

Ligne 10 : La fonction constructeur commence ici. Les constructeurs sont des fonctions spéciales en Solidity qui ne sont exécutées qu'une seule fois lors du déploiement du contrat. Ce constructeur prend un argument, propriétaire initial, qui est une adresse Ethereum.

Ligne 11 : cette ligne appelle le constructeur du contrat ERC721 avec les arguments « MyToken » et « MTK ». Elle initialise le contrat NFT avec le nom « MyToken » et le symbole « MTK ».

Ligne 12 : cette ligne appelle le constructeur du contrat « Ownable » et définit le propriétaire initial du contrat « MyToken » comme étant l'adresse fournie dans le paramètre « initialOwner ».

Ligne 15 : Déclaration de la fonction safeMint avec trois arguments : to (l'adresse du destinataire du jeton NFT), tokenId (l'identifiant unique du jeton) et uri (l'URI du fichier JSON associé au jeton). Cette fonction ne peut être appelée que par le propriétaire du contrat (spécifié par le propriétaire unique (modificateur).

Ligne 19 : Création d'un nouveau jeton en appelant la fonction _safeMint fonction héritée du contrat ERC721. Elle crée un nouveau jeton et l'attribue à l'adresse du destinataire spécifié.

Ligne 20 : Définition de l'URI du jeton (URI des métadonnées) associé au jeton à l'aide de la _setTokenURI fonction héritée de la ERC721URIStorage contrat. L'URI est défini en fonction du tokenId et de l'uri fournis.

Lignes 25 à 32 : implémentation des redéfinitions requises par Solidity pour la ERC721 et ERC721URIStorage contrats. tokenURI est une fonction qui récupère l'URI des métadonnées associées à un tokenId donné. Elle est marquée comme « public » et « view », ce qui indique qu'il s'agit d'une fonction en lecture seule et qu'elle peut être appelée par n'importe qui.

Lignes 34 à 41 : implémentation de la fonction `supportsInterface`, qui est requise par la ERC721 et ERC721URIStorage contrats. Cette fonction vérifie si un `interfaceId` donné est pris en charge par le contrat et renvoie une valeur booléenne en conséquence.

En combinant ces fonctionnalités et ces contrats, le code crée un contrat de jeton ERC721 personnalisé nommé MyToken. Ce contrat permet à son propriétaire de créer en toute sécurité de nouveaux jetons, de leur associer des URI de métadonnées, et prend en charge les interfaces nécessaires définies par la norme ERC721.

Prenez maintenant quelques instants pour personnaliser le contrat intelligent avec vos propres informations, si vous le souhaitez. Vous pouvez modifier le nom et le symbole du token en modifiant la ligne suivante : - ERC721 (« MyToken », « MTK »).

Une fois que vous avez terminé, compilez le contrat intelligent et déployez-le à l'aide de Fournisseur injecté (veillez à sélectionner le testnet Sepolia dans Metamask avant de compiler le contrat). Ensuite, collez l'adresse de votre portefeuille dans le champ situé juste à côté du Déployer bouton pour définir le propriétaire initial paramètre de la fonction constructeur. Enfin, cliquez sur Déployer sur Remix.IDE.

Onglet « Déploiement » de Remix.IDE

Si vous recevez un message d'erreur avant le déploiement — « Ce contrat est peut-être abstrait » —, veillez à sélectionner le contrat approprié dans l'onglet « Contrat ».

Confirmez la transaction dans Metamask :

Fenêtre MetaMask affichant les détails de la transaction

Rendez-vous maintenant dans la section « Contrats déployés » de Remix et développez le contrat déployé. Vous verrez alors toute une série de fonctions et de méthodes. Développez le safeMint fonction et ajoutez les informations suivantes :


  1. Saisissez l'adresse de votre portefeuille dans le champ _to.
  2. Saisissez n'importe quelle valeur de type « Big number » dans le champ _tokenId. Nous vous recommandons d'utiliser « 1 », car ce chiffre correspond au premier jeton émis.
  3. Pour le _uri Dans ce champ, saisissez l'URI du fichier JSON correspondant à la méthode que vous avez utilisée lors des étapes précédentes :

Capture d'écran de la fonction safeMint

Cliquez sur « Transact » et confirmez la transaction depuis MetaMask. Cela peut prendre quelques minutes, mais vous pouvez toujours vérifier que la transaction a bien été exécutée à l'aide d'un explorateur de blocs tel qu'Etherscan. Vous disposez désormais du NFT sur la chaîne Sepolia.

Vous pouvez consulter d'autres informations telles que nom, symbole, propriétaire de, ou tokenURI en saisissant l'identifiant du jeton que nous avons mentionné précédemment.

Interactions avec le contrat MyToken sur Remix.IDE

Conclusion​

Félicitations pour la création de votre tout premier NFT ! Aidez vos amis artistes à publier leurs œuvres sur la blockchain Ethereum, ou lancez-vous vous-même dans la création artistique. Découvrez l'assistant d'OpenZeppelin pour voir d'autres exemples.

Abonnez-vous à notre newsletter pour découvrir d'autres articles et guides sur Ethereum. Si vous avez des commentaires, n'hésitez pas à nous contacter sur Twitter. Vous pouvez également discuter avec nous sur notre serveur Discord, où vous rencontrerez certains des développeurs les plus géniaux qui soient :)

Nous ❤️ les commentaires !

Faites-nous savoir si vous avez des commentaires ou des suggestions de nouveaux sujets. Nous serions ravis de vous entendre.

Dernière mise à jour sur
Partager ce guide