Saltar al contenido
Obtén MetaMask
Obtén MetaMask

Guía sencilla sobre los tokens ERC-1155 en Ethereum

Explora la versatilidad del estándar de tokens ERC-1155 de Ethereum, aprende cómo simplifica la gestión de activos digitales y sigue una guía paso a paso para crear...

4 min de lectura
Guía sencilla sobre los tokens ERC-1155 en Ethereum

La blockchain de Ethereum ha transformado significativamente la creación y gestión de activos digitales. Entre estos avances, el estándar ERC-1155 surge como una innovación destacada. Introducido por el equipo de Enjin, ERC-1155 está diseñado para optimizar y mejorar la eficiencia de los activos digitales en la blockchain, permitiendo la creación de tokens fungibles, no fungibles y semifungibles, todo dentro de un único smart contract.

ERC-1155 fue desarrollado para abordar las ineficiencias de estándares de tokens anteriores, como ERC-20 y ERC-721. Mientras que ERC-20 es adecuado para tokens fungibles (donde cada token es idéntico e intercambiable) y ERC-721 para tokens no fungibles (donde cada token es único), estos estándares presentan limitaciones en alcance y eficiencia al gestionar múltiples tipos de tokens.

Algunos de los principales beneficios de ERC-1155 son:

  • Transferencias por lotes: ERC-1155 admite transferencias por lotes, lo que permite mover múltiples tipos de tokens en una sola transacción. Esto reduce significativamente los costos de gas y aumenta la velocidad de las transacciones.

  • Un único contrato para múltiples tokens: Este estándar permite que un único contrato gestione tanto tokens fungibles como no fungibles, simplificando el despliegue y reduciendo costos.

  • Verificaciones de transferencia segura: ERC-1155 garantiza que los tokens se envíen a direcciones compatibles, mejorando la seguridad de las transacciones y previniendo pérdidas por errores.

Algunas aplicaciones prácticas de ERC-1155:

  • Gaming: Permite gestionar toda una economía de objetos dentro del juego, desde consumibles hasta equipamiento raro, dentro de un único contrato.

  • Arte digital: Permite a los artistas emitir tanto piezas de edición limitada como de edición abierta de forma fluida.

  • Activos tokenizados: Los activos del mundo real pueden tokenizarse y gestionarse mediante ERC-1155.

Escritura y despliegue de un token ERC-1155

En este tutorial, crearemos un token ERC-1155 básico llamado RAD Token. Este ejemplo demostrará cómo se pueden gestionar diferentes activos dentro de un único framework de contrato.

  1. Configura tu entorno de desarrollo: Antes de comenzar, asegúrate de tener Node.js y npm instalados. Luego, configura tu proyecto Hardhat:

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

  1. Instala Hardhat y los contratos de OpenZeppelin

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

  1. Inicializa Hardhat

npx hardhat

Elige "Create an empty hardhat.config.js" cuando se te solicite.

  1. Escribe el contrato RADToken: Crea un nuevo archivo contracts/RADToken.sol y pega el código del contrato a continuación.


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

 }

}

Copiar

  1. Escribe el script de despliegue: Crea un nuevo archivo ignition/modules/RadToken.js para el módulo de despliegue de Hardhat Ignition y añade el código a continuación.

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

  1. Escribe los scripts de prueba: Crea un nuevo archivo test/RadToken.js para probar el contrato y añade el código a continuación:

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");
 });
 });
});
Copiar

  1. Prueba el código del contrato: Ejecuta las pruebas con el siguiente comando:

npx hardhat test

  1. Despliega el contrato RADToken: Compila y despliega el contrato con los siguientes comandos:

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

¿Qué sigue?

ERC-1155 representa un avance significativo en los estándares de tokens de Ethereum, ofreciendo mayor flexibilidad, eficiencia y utilidad que sus predecesores. El ejemplo de RAD Token demuestra la facilidad con la que se pueden gestionar múltiples tipos de tokens bajo un único contrato, abriendo la puerta a una nueva generación de aplicaciones descentralizadas.

Recursos útiles

Traducido por IA. Puede contener errores. Por favor, verifique siempre la información.

Califica la traducción

Este artículo fue escrito por:

Artículos más recientes

Todas las noticias