WEB3DEV Español

Cover image for Cómo construir tokens ERC-721 "Quemables" y "Pausables" utilizando OpenZeppelin y QuikNode
Juan José Gouvêa
Juan José Gouvêa

Posted on

Cómo construir tokens ERC-721 "Quemables" y "Pausables" utilizando OpenZeppelin y QuikNode

¡Abre las puertas a un nuevo nivel de personalización y control sobre tus tokens ERC-721 usando OpenZeppelin y QuikNode!

La revolución de la tokenización descentralizada ha sido un hito en la evolución de las finanzas y la propiedad digital. Los tokens ERC-721 han permitido la representación única de activos digitales, abriendo camino para innumerables aplicaciones en juegos, arte digital, coleccionables y mucho más. Sin embargo, hasta ahora, a menudo nos hemos enfrentado a limitaciones que hacían que ciertos escenarios fueran inviables o desafiantes.

Construyendo tokens coleccionables usando QuikNode

En un artículo reciente sobre How to Create a Burnable Token with Solidity and OpenZeppelin Library, construimos el token Botics (BTS) usando la biblioteca OpenZeppelin.

La tecnología blockchain ha revolucionado la forma en que se realizan las transacciones en diversas industrias. La capacidad de crear aplicaciones descentralizadas (dApps) basadas en contratos inteligentes ofrece mayor seguridad, transparencia e inmutabilidad.

Sin embargo, el desarrollo de contratos inteligentes puede ser complejo y susceptible de errores que pueden resultar en graves problemas de seguridad. Aquí es donde entra la biblioteca OpenZeppelin, una herramienta poderosa y ampliamente utilizada para facilitar el desarrollo seguro de contratos inteligentes en la blockchain.

Analizamos los diferentes métodos de los estándares ERC-721 y cómo funcionan. Si necesitas una introducción práctica, accede al siguiente artículo sobre los tokens ERC-721.

En el artículo de hoy, discutiré sobre los tokenomics del ERC-721, incluyendo características como 'quemado' y 'pausa', además de mostrar cómo desplegar tokens coleccionables usando QuikNode.io (nodo Ethereum como servicio).

QuikNode.io es una plataforma basada en la nube que ofrece servicios de Infraestructura de Nodo como Servicio para varias blockchains populares, incluyendo Ethereum, Binance Smart Chain, Polygon y mucho más. El objetivo de QuikNode.io es proporcionar a los desarrolladores y empresas una manera fácil y rápida de interactuar con la blockchain sin la necesidad de configurar y mantener un nodo completo.

Crea tu propio token ERC-20 en 30 segundos, sin escribir una línea de código, usando el Crowdbotics App Builder

Contratos de Quema de Tokens

La quema de tokens es un instrumento en tokenomics para disminuir la oferta del activo. En nuestro caso, como cada token es diferente, destruiremos un token(activo coleccionable) para disminuir la oferta total.

¿Cómo construir un token ERC-721 quemable?

Ahora, vamos a añadir la funcionalidad de quema en el token Botics que construimos en el último tutorial. Heredaremos el contrato ERC721Burnable.sol de la biblioteca open-zeppelin. Primero veamos este contrato.

Este archivo hereda ERC721.sol, verifica la propiedad del token y llama al método _burn de ERC721.sol.

pragma solidity ^0.4.24;
import "./ERC721.sol";
contract ERC721Burnable is ERC721 {
  function burn(uint256 tokenId)
    public
  {
    require(_isApprovedOrOwner(msg.sender, tokenId));
    _burn(ownerOf(tokenId), tokenId);
  }
}
Enter fullscreen mode Exit fullscreen mode

A continuación, está la función _burn del archivoERC721.sol. Elimina la propiedad y da la propiedad a address(0)(nadie tiene acceso a esta dirección) y luego emite el evento transfer.

function _burn(address owner, uint256 tokenId) internal {
    _clearApproval(owner, tokenId);
    _removeTokenFrom(owner, tokenId);
    emit Transfer(owner, address(0), tokenId);
  }
Enter fullscreen mode Exit fullscreen mode

Ahora, veamos los cambios en nuestro contrato. Agregaremos un pequeño método burn que llamará internamente a ERC721Burnable.sol.

function _burn(uint256 tokenId) public{
   burn(tokenId);
}
Enter fullscreen mode Exit fullscreen mode

Código completo de BoticsToken.sol

pragma solidity ^0.4.24;
import "/openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol";
import "/openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "/openzeppelin-solidity/contracts/token/ERC721/ERC721Burnable.sol";
contract BoticsToken is ERC721Full, Ownable, ERC721Burnable{

  constructor() 
  ERC721Full("Botics", "BTS")
  public {}
function mint(address to, uint256 tokenId) public onlyOwner {
   _mint(to, tokenId);
  }
function _mint(address to) public onlyOwner{
   mint(to, totalSupply().add(1));
  }
function _burn(uint256 tokenId) public{
   burn(tokenId);
  }
}
Enter fullscreen mode Exit fullscreen mode

¿Quién puede quemar un token ERC-721?

Hay tres actores que pueden quemar tokens en nuestro contrato:

Propietario: por supuesto que el dueño del token puede quemar sus tokens.

Cuenta aprobada: una cuenta aprobada por el propietario puede quemar el token.

Operador: un operador es similar a la cuenta aprobada, pero en este caso, el propietario aprueba el acceso a todos sus tokens de otra cuenta. Este es un arreglo típico de billeteras o intercambios.

Al diseñar tu contrato, debes tener cuidado con quién puede quemar tokens. Como las blockchains son inmutables, los tokens destruidos no pueden ser recuperados.

Probando el token quemable

Ahora, vamos a probar nuestro token quemable para cada uno de los tres actores que discutimos anteriormente.

Quema de token por el propietario del token

Un propietario de token puede quemar su token. Veamos cómo funcionará esto.

Usaremos la consola Truffle para probar nuestro contrato. Puedes invocar la consola Truffle usando: truffle develop

Ahora, vamos a acuñar algunos tokens y quemarlos.

// implantar contrato
truffle migrate --reset
//Obter instância de token
BoticsToken.deployed().then((botics) => {token = botics;})
//mintar um token (id : 1) to account 1
token.mint(web.eth.account[1] , 1 );
// Agora queimar o token (id : 1)
token._burn(1 , {from: web3.eth.accounts[1]})
Enter fullscreen mode Exit fullscreen mode

Quema de un token por una cuenta aprobada

Veamos cómo un token puede ser quemado por una cuenta aprobada.

//mintar outro token (id : 2) to account 1
token.mint(web.eth.account[1] , 1 );
//aprovar a conta-2 do token(id:2)
token.approve(web3.eth.accounts[2], 2,{from:web3.eth.accounts[1]})
// Agora queimar o token (id : 2) from account-2
token._burn(2 , {from: web3.eth.accounts[2]})
Enter fullscreen mode Exit fullscreen mode

De igual manera, un propietario puede aprobar todos los tokens para otra cuenta y esa cuenta podrá quemar todos los tokens.

Token ERC-721 Pausable

Vamos a dar a nuestro contrato una característica de pausa.

Un contrato pausable tiene mecanismos para detener las funcionalidades del contrato inteligente, como la transferencia o aprobación.

Todo contrato de activo debe tener esta funcionalidad. Hay varios beneficios de un contrato pausable. El principal beneficio del contrato de token pausable es la seguridad. En caso de cualquier vulnerabilidad de contrato que pueda ser necesaria para actualizar el contrato, la pausa puede detener las transferencias y otras funcionalidades clave, lo que reduce el riesgo general.

¿Cómo construir un token ERC-721 Pausable?

Construir un contrato pausable es muy fácil con la biblioteca OpenZeppelin. Open-zeppelin proporciona el contrato ERC721Pausable.sol, el cual puedes utilizar para ofrecer la funcionalidad de pausa para nuestro contrato ERC-721.

Solo necesitamos heredar ERC721Pausable.sol para proporcionar la característica de pausa en nuestro contrato.

Vamos a ver, ERC721Pausable.sol abarca tres funciones: approve, setApprovalForAll y transferFrom. También hereda Pausable.sol que controla internamente la funcionalidad de pausa.

pragma solidity ^0.4.24;
import "./ERC721.sol";
import "../../lifecycle/Pausable.sol";
contract ERC721Pausable is ERC721, Pausable {
  function approve(
    address to,
    uint256 tokenId
  )
    public
    whenNotPaused
  {
    super.approve(to, tokenId);
  }
function setApprovalForAll(
    address to,
    bool approved
  )
    public
    whenNotPaused
  {
    super.setApprovalForAll(to, approved);
  }
function transferFrom(
    address from,
    address to,
    uint256 tokenId
  )
    public
    whenNotPaused
  {
    super.transferFrom(from, to, tokenId);
  }
}
Enter fullscreen mode Exit fullscreen mode

Vamos a ver el contrato Pausable.sol heredado por ERC721Pausable.sol. Este contrato pausable también hereda usando PauserRole.sol, con el cual puedes controlar quién puede pausar el contrato.

pragma solidity ^0.4.24;
import "../access/roles/PauserRole.sol";

contract Pausable is PauserRole {
  event Paused(address account);
  event Unpaused(address account);
bool private _paused;
constructor() internal {
    _paused = false;
  }

  function paused() public view returns(bool) {
    return _paused;
  }
  modifier whenNotPaused() {
    require(!_paused);
    _;
  }

  modifier whenPaused() {
    require(_paused);
    _;
  }

  function pause() public onlyPauser whenNotPaused {
    _paused = true;
    emit Paused(msg.sender);
  }

  function unpause() public onlyPauser whenPaused {
    _paused = false;
    emit Unpaused(msg.sender);
  }
}
Enter fullscreen mode Exit fullscreen mode

Probando un token ERC-721 pausado

Vamos a probar nuestro token pausable. Antes de eso, compila y vuelve a implementar el Token Botics.

//Obtenha a instância do token e crie um novo token e atribua-o à conta-1
token.mint(web3.eth.accounts[1], 1);
//Vamos transferir este token para a conta-2
token.safeTransferFrom(web3.eth.accounts[1], web3.eth.accounts[2], 1, {from:web3.eth.accounts[1]})
//Agora vamos pausar o contrato
token.pause();
//Vamos verificar se o token está pausado ou não?
token.paused();
//Agora vamos tentar transferir o token novamente, Deve dar um erro
token.safeTransferFrom(web3.eth.accounts[2], web3.eth.accounts[3], 1, {from:web3.eth.accounts[2]})
Enter fullscreen mode Exit fullscreen mode

Puedes probar otros métodos como approve, deberían estar dando error cuando el contrato esté pausado.

Implementar Token Usando QuikNode

Vamos a desplegar nuestro token Crowdbotics (Botics) usando QuikNode.

QuikNode ofrece el nodo Ethereum como servicio y socio de la plataforma Crowdbotics.

Para esto, utilizaremos truffle-HD-wallet, así que vamos a instalarla.

npm install truffle-hdwallet-provider

Necesitamos registrarnos y obtener una URL HttpProvider, para ello revisa la publicación Corre tu propio nodo Ethereum. A continuación, está la configuración de Truffle para QuikNode usando la red kovan.

var HDWalletProvider = require("truffle-hdwallet-provider");
var mnemonic = "YOUR_MEMONICS"; // usar uma carteira com fundos
module.exports = {
    networks: {
        development: {
            host: "127.0.0.1",
            port: 7545,
            network_id: "*" // Combine qualquer id de rede
        },
        kovan: {
            provider: function() {
                return new HDWalletProvider(mnemonic, "https://mistakenly-smart-jay.quiknode.io/86d9e35e-8cdb-47ad-80a4-84f9e9537afa/C0_tKUunhUc0rM_i1HMxHA==/")
            },
            network_id: 42
        }
    }
};
Enter fullscreen mode Exit fullscreen mode

Conclusión sobre Cómo Construir Tokens ERC-721 Quemables y Pausables

Aprendimos cómo hacer que su token ERC-721 sea quemable y pausable. Exploraremos algunas características adicionales en el próximo artículo. Háganos saber si desea aprender más sobre el token ERC-721 en la sección de comentarios.

Si está construyendo algo, puede consultar DotLicense, que es un marco de licencia de software basado en ERC721 de Ethereum. Vea que puede crear una licencia de software utilizando el token ERC-721.

Hay muchos casos de uso increíbles en torno al token ERC-721. ¿En qué estás trabajando para utilizar los tokens ERC-721?

Este artículo fue escrito por Gaurav Agrawal y traducido por Juan José Gouvêa.

Queridos entusiastas de la tecnología blockchain y desarrolladores que desean explorar el universo de las aplicaciones web3.

Aproveche la oportunidad de elevar su trayectoria de desarrollo a un nivel superior. Construir Tokens ERC-721 es solo el comienzo; los builds de la WEB3DEV son la puerta de entrada al paisaje web3.

Discussion (0)