Aller au contenu
Obtenir MetaMask
Obtenir MetaMask

Guide simple sur les tokens ERC-1155 sur Ethereum

Découvrez la polyvalence du standard de token ERC-1155 d'Ethereum, apprenez comment il simplifie la gestion des actifs numériques et suivez un guide étape par étape pour créer...

4 min de lecture
Guide simple sur les tokens ERC-1155 sur Ethereum

La blockchain Ethereum a considérablement transformé la création et la gestion des actifs numériques. Parmi ces avancées, le standard ERC-1155 s'impose comme une innovation remarquable. Introduit par l'équipe d'Enjin, l'ERC-1155 est conçu pour rationaliser et améliorer l'efficacité des actifs numériques sur la blockchain en permettant la création de tokens fongibles, non fongibles et semi-fongibles — le tout au sein d'un seul smart contract.

L'ERC-1155 a été développé pour remédier aux inefficacités des standards de tokens précédents, tels que l'ERC-20 et l'ERC-721. Si l'ERC-20 est adapté aux tokens fongibles (où chaque token est identique et interchangeable) et l'ERC-721 aux tokens non fongibles (où chaque token est unique), ces standards présentent des limites en termes de portée et d'efficacité lorsqu'il s'agit de gérer plusieurs types de tokens.

Voici quelques-uns des principaux avantages de l'ERC-1155 :

  • Transferts par lot : L'ERC-1155 prend en charge les transferts par lot, permettant de déplacer plusieurs types de tokens en une seule transaction. Cela réduit considérablement les frais de gas et augmente la vitesse des transactions.

  • Un seul contrat pour plusieurs tokens : Ce standard permet à un seul contrat de gérer à la fois des tokens fongibles et non fongibles, simplifiant ainsi le déploiement et réduisant les coûts.

  • Vérifications de transfert sécurisées : L'ERC-1155 garantit que les tokens sont envoyés vers des adresses compatibles, renforçant la sécurité des transactions et prévenant les pertes dues à des erreurs.

Voici quelques applications concrètes de l'ERC-1155 :

  • Gaming : Permet de gérer une économie entière d'objets en jeu, des consommables aux équipements rares, au sein d'un seul contrat.

  • Art numérique : Permet aux artistes d'émettre aussi bien des œuvres en édition limitée qu'en édition ouverte, de manière fluide.

  • Actifs tokenisés : Des actifs du monde réel peuvent être tokenisés et gérés grâce à l'ERC-1155.

Écriture et déploiement d'un token ERC-1155

Dans ce tutoriel, nous allons créer un token ERC-1155 de base appelé RAD Token. Cet exemple illustrera comment différents actifs peuvent être gérés au sein d'un même framework de contrat.

  1. Configurez votre environnement de développement : Avant de commencer, assurez-vous d'avoir Node.js et npm installés. Ensuite, configurez votre projet Hardhat :

mkdir rad-token
cd rad-token
npm init -y
Copier

  1. Installez Hardhat et les contrats OpenZeppelin

npm install --save-dev hardhat 
npm install @openzeppelin/contracts
Copier

  1. Initialisez Hardhat

npx hardhat

Choisissez « Create an empty hardhat.config.js » lorsque vous y êtes invité.

  1. Rédigez le contrat RADToken : Créez un nouveau fichier contracts/RADToken.sol et collez-y le code du contrat ci-dessous.


// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

import "@openzeppelin/contracts/access/Ownable.sol";

import "@openzeppelin/contracts/utils/Strings.sol";

contract RADToken is ERC1155, Ownable {

    constructor(address initialOwner, string memory baseURI) ERC1155(baseURI) Ownable(initialOwner) {

        // Initialize contract with metadata URI

 }

    function mint(address account, uint256 id, uint256 amount, bytes memory data)

        public

        onlyOwner

 {

        _mint(account, id, amount, data);

 }

    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)

        public

        onlyOwner

 {

        _mintBatch(to, ids, amounts, data);

 }

    function setURI(string memory newuri) public onlyOwner {

        _setURI(newuri);

 }

    function uri(uint256 tokenId) public view override returns (string memory) {

        return string(abi.encodePacked(super.uri(tokenId), Strings.toString(tokenId), ".json"));

 }

    function burn(address account, uint256 id, uint256 amount) public onlyOwner {

        _burn(account, id, amount);

 }

    function burnBatch(address account, uint256[] memory ids, uint256[] memory amounts)

        public

        onlyOwner

 {

        _burnBatch(account, ids, amounts);

 }

}

Copier

  1. Rédigez le script de déploiement : Créez un nouveau fichier ignition/modules/RadToken.js pour le module de déploiement Hardhat Ignition et ajoutez-y le code ci-dessous.

const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
module.exports = buildModule("RADTokenModule", (m) => {
  const deployer = m.getAccount(0);
  const baseURI = m.getParameter(
    "baseURI",
"<https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/>"
);
  const radToken = m.contract("RADToken", [deployer, baseURI]);
  return { radToken };
});
Copier

  1. Rédigez les scripts de test : Créez un nouveau fichier test/RadToken.js pour tester le contrat et ajoutez-y le code ci-dessous :

const { expect } = require("chai");
const { ethers } = require("hardhat");
const {
  loadFixture,
} = require("@nomicfoundation/hardhat-toolbox/network-helpers");

describe("RADToken", function () {
  async function deployRADTokenFixture() {
    const [owner, addr1, addr2, ...addrs] = await ethers.getSigners();
    const RADToken = await ethers.getContractFactory("RADToken");
    const baseURI =
      "https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/";
    const radToken = await RADToken.deploy(owner.address, baseURI);

    return { radToken, owner, addr1, addr2, addrs };
 }

  describe("Minting", function () {
    it("Should mint a token", async function () {
      const { radToken, addr1 } = await loadFixture(deployRADTokenFixture);
      await radToken.mint(addr1.address, 1, 100, "0x");
      expect(await radToken.balanceOf(addr1.address, 1)).to.equal(100);
 });

    it("Should mint multiple tokens in batch", async function () {
      const { radToken, addr1 } = await loadFixture(deployRADTokenFixture);
      await radToken.mintBatch(addr1.address, [1, 2], [100, 200], "0x");
      expect(await radToken.balanceOf(addr1.address, 1)).to.equal(100);
      expect(await radToken.balanceOf(addr1.address, 2)).to.equal(200);
 });
 });

  describe("URI Management", function () {
    it("Should return correct token URI", async function () {
      const { radToken } = await loadFixture(deployRADTokenFixture);
      expect(await radToken.uri(1)).to.equal(
        "https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/1.json"
 );
 });

    it("Should set new URI and return correct token URI", async function () {
      const { radToken } = await loadFixture(deployRADTokenFixture);
      const newBaseURI = "https://newbase.uri/";
      await radToken.setURI(newBaseURI);
      expect(await radToken.uri(1)).to.equal("https://newbase.uri/1.json");
 });
 });
});
Copier

  1. Testez le code du contrat : Exécutez les tests avec la commande suivante :

npx hardhat test

  1. Déployez le contrat RADToken : Compilez et déployez le contrat avec les commandes suivantes :

npx hardhat compile 
npx hardhat ignition --network localhost --show-logs ignition/modules/RadToken.js
Copier

Et maintenant ?

L'ERC-1155 représente une avancée majeure dans les standards de tokens d'Ethereum, offrant une plus grande flexibilité, efficacité et utilité par rapport à ses prédécesseurs. L'exemple du RAD Token démontre la facilité avec laquelle plusieurs types de tokens peuvent être gérés au sein d'un seul contrat, ouvrant la voie à une nouvelle génération d'applications décentralisées.

Ressources utiles

Traduit par IA. Peut contenir des erreurs. Veuillez toujours vérifier les informations.

Évaluer la traduction

Cet article a été rédigé par :

Derniers articles

Toute l'actualité