Comment créer un NFT et le vendre sur OpenSea ?

Mis à jours 29 avril 2021

Dans cet article, je vais vous montrer comment créer un NFT sans avoir des connaissances en génie logiciel. Ensuite, nous allons apprendre à créer des NFT personnalisables illimitées avec Brownie, Python et Chainlink. Et nous allons voir comment présenter et vendre notre création sur la marketplace des NFT sur OpenSea. N’oubliez pas de sauvegarder votre copie originale sur un Wallet Hardware comme Ledger

Si vous recherchez un tutoriel utilisant Truffle, JavaScript et des personnages médiévaux amusants, découvrez comment créer, déployer et vendre votre NFT en cliquant ici.

Qu’est-ce qu’un NFT ?

Pour résumer, les NFT (jetons non fongibles ou Non-Fungible Tokens) en un seul mot, c’est « unique ». Plus précisément, ce sont des contrats intelligents déployés sur une blockchain qui représentent quelque chose d’unique.

ERC20 vs ERC721

Les NFT sont une norme de jeton blockchain similaire à l’ERC20, comme AAVE, SNX et LINK (techniquement un ERC677). Les ERC20 sont des jetons « fongibles », ce qui signifie « remplaçables » ou encore « interchangeables ».

À titre d’exemple, votre billet d’un Euro vaudra 1 € quel que soit le billet que vous utilisez. Le numéro de série sur le billet d’un Euro peut être différent, mais les billets sont interchangeables et valent 1 € quoi qu’il arrive.

Les NFT, quant à eux, sont « non fongibles » et suivent leur propre norme de jeton, l’ERC721. À titre d’exemple, la Joconde est « non fongible ». Même si quelqu’un peut en faire une copie, il n’y aura toujours qu’une seule Joconde. Si la Joconde était créée sur une blockchain, ce serait un NFT.

Créer un NFT

À quoi servent les NFT ?

Les NFT apportent de la valeur aux créateurs, aux artistes, aux concepteurs de jeux et plus encore en ayant un historique permanent de déploiement stocké on-chain.

Vous saurez toujours qui a créé le NFT, qui le possédait, d’où il venait. En outre, vous leur donnez beaucoup plus de valeur par rapport à l’art traditionnel. Dans l’art traditionnel, il peut être difficile de reconnaître un « faux », alors qu’en chaîne, il est très facile de tracer l’histoire.

Et comme les contrats intelligents et les NFT sont programmables à 100%, les NFT peuvent également avoir des redevances intégrées et toute autre fonctionnalité. La compensation des artistes a toujours été un problème, car souvent le travail d’un artiste est répandu sans aucune attribution.

De plus en plus d’artistes et d’ingénieurs sautent sur cette valeur ajoutée importante, car c’est enfin un excellent moyen pour les artistes d’être rémunérés équitablement pour leur travail. En outre, les NFT sont un moyen amusant de montrer votre créativité et de devenir un collectionneur dans un monde numérique.

La valeur des NFT

Les NFTs ont parcouru un long chemin, et nous continuons à voir des ventes record de NFT, comme « Everydays: The First 5,000 Days » qui se vendent à 69,3 millions de dollars.

Il y a donc beaucoup de valeur lorsqu’il s’agit de NFT. D’ailleurs, et c’est aussi une façon amusante, dynamique et engageante de créer de l’art dans le monde numérique et d’en apprendre davantage sur la création de contrats intelligents. Alors maintenant, je vais vous apprendre tout ce que vous devez savoir sur la création de NFT.

Comment créer un NFT ?

Ce que nous n’allons pas voir

Désormais, le moyen le plus simple de créer un NFT consiste à accéder à une plateforme comme OpenSea, Rarible ou Mintible. Ensuite, il faut suivre leur guide étape par étape pour le déploiement sur leur plateforme.

Vous pouvez choisir cette option à 100%. Cela dit, vous pourriez être lié à la plateforme et vous familiariser avec ses fonctionnalités. Cependant, vous ne pouvez pas tirer parti de la personnalisation illimitée ni utiliser aucun des avantages des NFT. Mais si vous êtes un ingénieur logiciel débutant ou pas très technique, c’est la solution idéale pour vous.

Si vous cherchez à devenir un ingénieur logiciel expert, à acquérir des connaissances avec le langage SOLIDITY d’Ethereum et pouvoir de créer quelque chose avec une créativité illimitée, alors lisez la suite !

Si vous êtes nouveau avec le langage Solidity, ne vous inquiétez pas. je vous monterai les bases de ce langage également.

Comment créer un NFT avec une personnalisation illimitée ?

Je vais vous aider à démarrer avec ce Brownie Mix NFT. Il s’agit d’un dépôt fonctionnel avec beaucoup de code standard.

Conditions préalables

Nous avons besoin d’installer quelques éléments pour commencer :

Si vous ne connaissez pas Metamask, vous pouvez consulter ce tutoriel pour l’installer.

Testnet Rinkeby ETH et LINK

Nous travaillerons également sur le testnet Rinkeby Ethereum, nous allons donc déployer nos contrats sur une véritable blockchain, et ce, gratuitement !

Les testnets sont d’excellents moyens de tester le comportement de nos contrats intelligents dans le monde réel. Nous avons besoin de Rinkeby ETH et de Rinkeby LINK, que nous pouvons obtenir gratuitement à partir des liens vers les derniers faucets de la documentation Chainlink.

Nous devrons également ajouter le jeton rinkeby LINK à notre Metamask, ce que nous pouvons faire en suivant la documentation d’acquisition LINK.

Si vous êtes toujours confus, vous pouvez suivre cette vidéo, assurez-vous simplement d’utiliser Rinkeby au lieu de Ropsten.

Lorsque nous travaillons avec une plateforme de contrats intelligents comme Ethereum, nous devons payer un peu d’ETH, et lorsque nous obtenons des données off-chain, nous devons payer un peu de LINK. C’est pourquoi nous avons besoin du testnet LINK et de l’ETH.

Super ! Nous allons voir plus de détails. C’est le NFT que nous allons déployer sur OpenSea.

Opensea

Démarrage rapide

git clone https://github.com/PatrickAlphaC/nft-mix
cd nft-mix

Super ! Maintenant, nous devons installer ganache-cli et eth-brownie.

pip install eth-brownie
npm install -g ganache-cli

Maintenant, nous pouvons définir nos variables d’environnement. Si vous n’êtes pas familier avec les variables d’environnement, vous pouvez juste les ajouter dans votre fichier .env. Un exemple de ce fichier « .env » doit se trouver dans le dépôt que vous venez de cloner. Ensuite exécuter la commande suivante:

source .env

Vous aurez besoin d’un WEB3_INFURA_PROJECT_ID et d’un PRIVATE_KEY. Le WEB3_INFURA_PROJECT_ID peut être trouvé lors de la création d’un compte Infura gratuit. Cela nous permettra d’envoyer des transactions à la blockchain.

Nous aurons également besoin d’une clé privée, que vous pouvez obtenir à partir de votre Metamask.

  1. Cliquez sur les 3 petits points,
Cliquez sur les 3 petits points du Metamask

2. Puis cliquez sur Détails du compte et Exporter la clé privée. Veuillez NE PAS partager cette clé avec qui que ce soit si vous y mettez de l’argent réel !

 Exporter la clé privée
PRIVATE_KEY=VOTRE_CLE_ICI
WEB3_INFURA_PROJECT_ID=ID_VOTRE_PROJET_ICI

Maintenant, nous pouvons déployer notre contrat NFT et créer notre premier objet de collection avec les deux commandes suivantes.

brownie run scripts/simple_collectible/deploy_simple.py --network rinkeby
brownie run scripts/simple_collectible/create_collectible.py --network rinkeby

Le premier script déploie notre contrat NFT sur la blockchain Rinkeby, et le second crée notre premier objet de collection.

Vous venez de déployer votre tout premier contrat intelligent !

Cela ne fait pas grand-chose du tout, mais ne vous inquiétez pas ! Je vais vous montrer comment le présenter sur OpenSea dans la partie avancée de ce tutoriel. Mais tout d’abord, allons voir la norme de Jeton ERC721.

La norme de jeton ERC721

Jetons un coup d’œil au contrat que nous venons de déployer, dans le fichier SimpleCollectible.sol.

// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract SimpleCollectible is ERC721 {
    uint256 public tokenCounter;
    constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

    function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

}

Nous utilisons le package OpenZepplin pour le jeton ERC721. Ce package que nous avons importé nous permet d’utiliser toutes les fonctionnalités d’un jeton ERC721 typique. Cela définit toutes les fonctionnalités que nos jetons vont avoir, comme le transfer qui déplace les jetons vers les nouveaux utilisateurs, safeMint qui crée de nouveaux jetons, et plus encore.

Vous pouvez trouver toutes les fonctionnalités qui sont données à notre contrat en consultant le contrat de jeton ERC721 OpenZepplin. Notre contrat hérite de ces fonctionnalités sur cette ligne :

contract SimpleCollectible is ERC721 {

C’est ainsi que la Solidity fait l’héritage. Lorsque nous déployons un contrat, le constructor est automatiquement appelé, et il prend quelques paramètres.

constructor () public ERC721 ("Dogie", "DOG"){
        tokenCounter = 0;
    }

Nous utilisons également le constructeur de l’ERC721, dans notre constructeur, et il suffit de lui donner un nom et un symbole. Dans notre cas, c’est « Dogie » et « DOG ». Cela signifie que chaque NFT que nous créons sera de type Dogie/DOG.

C’est comme si chaque carte Pokémon est toujours un pokémon, ou chaque joueur de football sur une carte de collection (trading card) est toujours un joueur de football. Chaque joueur est unique, mais ce sont toujours des footballeurs. Nous utilisons simplement le type DOG.

Ci-dessus, nous avons tokenCounter qui compte le nombre de NFT que nous avons créés de ce type. Chaque nouveau jeton a un tokenId basé sur tokenCounter actuel.

Nous pouvons en fait créer un NFT avec la fonctionnalité createCollectible. C’est ce que nous appelons dans notre script create_collectible.py.

function createCollectible(string memory tokenURI) public returns (uint256) {
        uint256 newItemId = tokenCounter;
        _safeMint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);
        tokenCounter = tokenCounter + 1;
        return newItemId;
    }

La fonctionnalité _safeMint crée le nouveau NFT et l’assigne à celui qui a appelé createdCollectible, aussi connu comme msg.sender, avec un newItemId dérivé de tokenCounter. C’est ainsi que nous pouvons garder une trace de qui possède quoi, en vérifiant le propriétaire du tokenId.

Vous remarquerez que nous appelons également _setTokenURI. Parlons de ça.

Quelles sont les métadonnées NFT et TokenURI ?

Lors de la création de contrats intelligents et de la création de NFT, les gens se sont rapidement rendu compte qu’il était vraiment coûteux de déployer beaucoup de données sur la blockchain. Des images aussi petites que 1 Ko peuvent facilement coûter plus d’un million de dollars à stocker.

C’est clairement un problème pour les NFT, car avoir de l’art créatif signifie que vous devez stocker ces informations quelque part. En outre, les gens voulaient également un moyen léger de stocker les attributs d’un NFT, et c’est là que le tokenURI et les métadonnées entrent en jeu.

TokenURI

Le tokenURI sur un NFT est un identifiant unique de ce à quoi le jeton « ressemble ». Un URI peut être un appel d’API via HTTPS, un hachage IPFS ou tout autre élément unique.

Il suit une norme pour afficher les métadonnées. Cela ressemble à ce qui suit :

{
    "name": "name",
    "description": "description",
    "image": "https://ipfs.io/ipfs/QmTgqnhFBMkfT9s8PHKcdXBn1f5bG3Q5hmBaR4U6hoTvb1?filename=Chainlink_Elf.png",
    "attributes": [
        {
            "trait_type": "trait",
            "value": 100
        }
    ]
}

Celui-ci montre à quoi ressemble un NFT et ses attributs. La section image pointe vers un autre URI pour afficher ce à quoi ressemble le NFT. Cela permet aux plateformes NFT comme OpenSea, Rarible et Mintable de présenter facilement les NFT sur leurs plateformes, car elles recherchent toutes ces métadonnées.

Métadonnées off-chain vs métadonnées on-chain

Maintenant, vous pensez peut-être « attendez … si les métadonnées ne sont pas on-chain, cela signifie-t-il que mon NFT pourrait disparaître à un moment donné ? » Et vous auriez raison.

En outre, vous auriez également raison de penser que les métadonnées off-chain signifient que vous ne pouvez pas utiliser ces métadonnées pour que vos contrats intelligents interagissent les uns avec les autres.

C’est pourquoi nous voulons nous concentrer sur les métadonnées on-chain, afin de pouvoir programmer nos NFT pour qu’ils interagissent les uns avec les autres.

Cependant, nous avons toujours besoin de la partie image des métadonnées off-chain, car nous n’avons pas un excellent moyen de stocker de grandes images sur la chaîne (on-chain). Mais ne vous inquiétez pas ! Nous pouvons le faire gratuitement sur un réseau décentralisé toujours à l’aide de IPFS.

Voici un exemple d’imageURI d’IPFS qui montre Chainlink Elf créé dans le tutoriel Dungeons and Dragons.

Créer un NFT Chainlink Elf
Chainlink Elf

Nous n’avons pas défini de tokenURI pour le NFT simple, car nous voulions juste montrer un exemple de base.

Passons maintenant au NFT avancé, afin que nous puissions voir certaines des fonctionnalités intéressantes que nous pouvons faire avec les métadonnées on-chain. Nous pouvons également avoir le NFT présenté sur opeansea et obtenir notre Dogie !

Si vous voulez une vidéo de rappel sur la section que nous venons de parcourir, suivez le déploiement d’un NFT.

NFT dynamiques et avancés

Les NFT dynamiques sont des NFT qui peuvent évoluer avec le temps ou qui ont des fonctionnalités on-chain que nous pouvons utiliser pour interagir les uns avec les autres. Ce sont les NFT qui ont la personnalisation illimitée. Ils nous permettent de créer des jeux entiers, des mondes ou de l’art interactif de quelque sorte que ce soit. Passons à la section avancée.

Démarrage rapide avancé

Assurez-vous d’avoir suffisamment de testnet ETH et LINK dans votre MetaMask, puis exécutez ce qui suit :

brownie run scripts/advanced_collectible/deploy_advanced.py --network rinkeby
brownie run scripts/advanced_collectible/create_collectible.py --network rinkeby

Dans cet exemple, notre objet de collection est une race de chien aléatoire retournée par le Chainlink VRF. Chainlink VRF est un moyen d’obtenir des nombres aléatoires prouvables, et donc une vraie rareté dans nos NFT. Nous voulons ensuite créer ses métadonnées.

brownie run scripts/advanced_collectible/create_metadata.py --network rinkeby

Ensuite, nous pouvons éventuellement télécharger ces données sur IPFS afin que nous puissions avoir un tokenURI. Je vais vous montrer comment le faire plus tard. Pour l’instant, nous allons juste utiliser l’exemple tokenURI de :

https://ipfs.io/ipfs/Qmd9MCGtdVz2miNumBHDbvj8bigSgTwnr4SbyH6DNnpWdt?filename=1-PUG.json

Si vous téléchargez IPFS Companion dans votre navigateur, vous pouvez utiliser cette URL pour voir ce que l’URI renvoie. Voici à quoi cela va ressembler :

{
    "name": "PUG",
    "description": "An adorable PUG pup!",
    "image": "https://ipfs.io/ipfs/QmSsYRx3LpDAb1GZQm7zZ1AuHZjfbPkD6J7s9r41xu1mf8?filename=pug.png",
    "attributes": [
        {
            "trait_type": "cuteness",
            "value": 100
        }
    ]
}

Ensuite, nous pouvons exécuter notre script set_tokenuri.py :

brownie run scripts/advanced_collectible/set_tokenuri.py --network rinkeby

Et nous aurions une sortie comme celle-ci :

Running 'scripts/advanced_collectible/set_tokenuri.py::main'...
Working on rinkeby
Transaction sent: 0x8a83a446c306d6255952880c0ca35fa420248a84ba7484c3798d8bbad421f88e
  Gas price: 1.0 gwei   Gas limit: 44601   Nonce: 354
  AdvancedCollectible.setTokenURI confirmed - Block: 8331653   Gas used: 40547 (90.91%)

Awesome! You can view your NFT at https://testnets.opensea.io/assets/0x679c5f9adC630663a6e63Fa27153B215fe021b34/0
Please give up to 20 minutes, and hit the "refresh metadata" button

Maintenant, nous pouvons cliquer sur le lien donné pour voir à quoi cela ressemble sur OpenSea. Vous devrez peut-être appuyer sur le bouton d’actualisation des métadonnées (refresh metadata) et attendre quelques minutes.

Actualiser les métadonnées NFT
Actualiser les métadonnées

La race aléatoire

Parlons de ce que nous venons de faire. Voici notre AdvancedCollectible.sol :

pragma solidity 0.6.6;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";

contract AdvancedCollectible is ERC721, VRFConsumerBase {
    uint256 public tokenCounter;
    enum Breed{PUG, SHIBA_INU, BRENARD}
    // add other things
    mapping(bytes32 => address) public requestIdToSender;
    mapping(bytes32 => string) public requestIdToTokenURI;
    mapping(uint256 => Breed) public tokenIdToBreed;
    mapping(bytes32 => uint256) public requestIdToTokenId;
    event requestedCollectible(bytes32 indexed requestId); 


    bytes32 internal keyHash;
    uint256 internal fee;
    uint256 public randomResult;
    constructor(address _VRFCoordinator, address _LinkToken, bytes32 _keyhash)
    public 
    VRFConsumerBase(_VRFCoordinator, _LinkToken)
    ERC721("Dogie", "DOG")
    {
        tokenCounter = 0;
        keyHash = _keyhash;
        fee = 0.1 * 10 ** 18;
    }

    function createCollectible(string memory tokenURI, uint256 userProvidedSeed) 
        public returns (bytes32){
            bytes32 requestId = requestRandomness(keyHash, fee, userProvidedSeed);
            requestIdToSender[requestId] = msg.sender;
            requestIdToTokenURI[requestId] = tokenURI;
            emit requestedCollectible(requestId);
    }

    function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
        address dogOwner = requestIdToSender[requestId];
        string memory tokenURI = requestIdToTokenURI[requestId];
        uint256 newItemId = tokenCounter;
        _safeMint(dogOwner, newItemId);
        _setTokenURI(newItemId, tokenURI);
        Breed breed = Breed(randomNumber % 3); 
        tokenIdToBreed[newItemId] = breed;
        requestIdToTokenId[requestId] = newItemId;
        tokenCounter = tokenCounter + 1;
    }

    function setTokenURI(uint256 tokenId, string memory _tokenURI) public {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _setTokenURI(tokenId, _tokenURI);
    }
}

Nous utilisons le Chainlink VRF pour créer une race aléatoire à partir d’une liste de PUG, SHIBA_INU, BRENARD. Lorsque nous appelons createCollectible cette fois, nous avons en fait lancé une requête au nœud Chainlink VRF hors chaîne (off-chain), et nous sommes retournés avec un nombre aléatoire pour créer le NFT avec l’une de ces 3 races.

L’utilisation du vrai hasard dans vos NFT est un excellent moyen de créer une vraie rareté, et l’utilisation d’un nombre aléatoire d’oracle Chainlink signifie que votre nombre est prouvé aléatoire et ne peut pas être influencé par les mineurs.

Vous pouvez en savoir plus sur Chainlink VRF dans la documentation en cliquant ici.

Le nœud Chainlink répond en appelant la fonctionnalité fulfillRandomness et crée l’objet de collection en fonction du nombre aléatoire. Alors, nous devons appeler _setTokenURI pour donner à notre NFT l’apparence dont il a besoin.

Là, nous n’avons pas donné nos attributs NFT, mais les attributs sont un excellent moyen pour nos NFT afin qu’ils puissent interagir. Vous pouvez voir un excellent exemple de NFT avec des attributs dans cet exemple de Dungeons and Dragons.

Métadonnées d’IPFS

Nous utilisons IPFS pour stocker deux fichiers :

  1. L’image du NFT (l’image du pug)
  2. Le fichier tokenURI (le fichier JSON qui comprend également le lien de l’image)

Nous utilisons IPFS car c’est une plateforme décentralisée gratuite. Nous pouvons ajouter nos tokenURI et images à IPFS en téléchargeant IPFS pour pc et en appuyant sur le bouton d’importation (import).

 IPFS pour pc
Ajouter un fichier à IPFS

Ensuite, nous pouvons partager l’URI en appuyant sur les 3 points à côté du fichier que nous voulons partager, en cliquant sur le lien de partage (share link) et en copiant le lien donné. Puis, nous pouvons ajouter ce lien dans notre fichier set_tokenuri.py pour changer l’URI du jeton que nous voulons utiliser.

La persistance

Cependant, si le tokenURI est uniquement sur notre nœud, cela signifie que lorsque notre nœud est en panne, personne d’autre ne peut le voir. Ainsi, nous voulons que d’autres pinnent notre NFT. Nous pouvons utiliser un service de pinning tel que Pinata pour aider à garder nos données en ligne même lorsque notre nœud IPFS est en panne.

J’imagine qu’à l’avenir, de plus en plus de métadonnées seront stockées sur IPFS et sur des plateformes de stockage décentralisées. En effet, les serveurs centralisés peuvent tomber en panne, ce qui signifie que l’art de ces NFT est perdu à jamais. Assurez-vous donc de vérifier où se trouve le tokenURI du NFT que vous utilisez !

Je m’attends également à ce que plus de gens utilisent les plateformes dStorage comme Filecoin, car l’utilisation d’un service de pinning n’est pas aussi décentralisée qu’elle devrait l’être.

Protéger vos NFT dans un endroit sécuritaire

Comme vous l’avez bien constaté, la création d’un NFT qui a de la valeur risque de prendre du temps et de l’effort. Alors, assurez-vous de sécuriser vos créations, et par la même, vos cryptos loin de l’internet.

La meilleure chose est de les enregistrer sur un Wallet Hardware comme Ledger.

Aller de l’avant

Si vous souhaitez voir une présentation vidéo du NFT avancé, vous pouvez regarder cette vidéo de NFT avancé.

Maintenant, vous avez les compétences nécessaires pour créer de superbes NFT amusants, personnalisables et interactifs, et les présenter sur une place de marché.

Les NFT sont des moyens amusants et puissants de faire rémunérer les artistes correctement pour tout le travail acharné qu’ils accomplissent. Bonne chance et amusez-vous !

Aina Strauss

À lire aussi

5 étapes pour créer votre propre application d’entraînement sans coder

Mis à jours 18 février 2021 Les vacances sont passées et il est temps de …

Share via
Copy link
Powered by Social Snap