Si eres un desarrollador blockchain, es muy probable que hayas oído hablar de las criptomonedas y, en particular, de los tokens ERC-20.

En este artículo, exploraremos qué son los tokens ERC-20, sus funciones clave y cómo puedes crear tu propio token en Solidity, tanto desde cero como utilizando OpenZeppelin.

¿Qué es el Estándar ERC-20?

ERC-20 es un conjunto de reglas que definen el comportamiento de los tokens en la red Ethereum. Fue propuesto para garantizar la interoperabilidad entre distintos smart contracts y aplicaciones dentro del ecosistema.

Los tokens ERC-20 pueden representar desde criptomonedas hasta activos digitales como puntos de lealtad o acciones en un proyecto.

Estos tokens son una parte fundamental del ecosistema Ethereum, ya que garantizan la interoperabilidad entre smart contracts y aplicaciones descentralizadas (dApps). Al seguir un conjunto estándar de reglas, los tokens ERC-20 pueden integrarse fácilmente en exchanges, wallets y otros servicios sin necesidad de adaptaciones adicionales, facilitando su uso y adopción.

Funciones Clave de ERC-20

Los smart contracts que implementan ERC-20 deben incluir ciertas funciones fundamentales para garantizar compatibilidad y seguridad. Algunas de ellas son:

• totalSupply(): Retorna la cantidad total de tokens en existencia.
• balanceOf(address _owner): Devuelve el saldo de tokens de una dirección.
• transfer(address _to, uint256 _value): Envía tokens de una cuenta a otra.
• approve(address _spender, uint256 _value): Autoriza a otra dirección a gastar tokens en nombre del propietario.
• allowance(address _owner, address _spender): Consulta cuántos tokens puede gastar un tercero en nombre de otro usuario.
• transferFrom(address _from, address _to, uint256 _value): Permite a una dirección transferir tokens desde otra, si tiene permiso para hacerlo.

Estas funciones estándar garantizan que cualquier token ERC-20 pueda integrarse sin problemas en distintas aplicaciones.

Creando un Token ERC-20

Veamos un ejemplo de un contrato ERC-20 básico:

pragma solidity ^0.8.0;

contract MyToken {
 string public constant name = "MyToken";
 string public constant symbol = "MTK";
 uint8 public constant decimals = 18;
 uint256 public totalSupply;

 mapping(address => uint256) balances;
 mapping(address => mapping(address => uint256)) allowed;

 event Transfer(
  address indexed _from,
  address indexed _to,
  uint256 _value
 );
 event Approval(
  address indexed _owner,
  address indexed _spender,
  uint256 _value
 );

 constructor(uint256 _initialSupply) {
  totalSupply = _initialSupply * 10**uint256(decimals);
  balances[msg.sender] = totalSupply;
  emit Transfer(address(0), msg.sender, totalSupply);
 }

 function balanceOf(address _owner) public view returns (uint256) {
  return balances[_owner];
 }

 function transfer(address _to, uint256 _value) public returns (bool) {
  require(_value <= balances[msg.sender], "Saldo insuficiente");
  require(_to != address(0), "Dirección inválida");

  balances[msg.sender] -= _value;
  balances[_to] += _value;
  emit Transfer(msg.sender, _to, _value);
  return true;
 }

 function approve(address _spender, uint256 _value) public returns (bool) {
  allowed[msg.sender][_spender] = _value;
  emit Approval(msg.sender, _spender, _value);
  return true;
 }

 function allowance(address _owner, address _spender) public view returns (uint256) {
  return allowed[_owner][_spender];
 }

 function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
  require(_value <= balances[_from], "Saldo insuficiente");
  require(_value <= allowed[_from][msg.sender], "No autorizado");
  require(_to != address(0), "Dirección inválida");

  balances[_from] -= _value;
  balances[_to] += _value;
  allowed[_from][msg.sender] -= _value;
  emit Transfer(_from, _to, _value);
  return true;
 }
}

Este contrato implementa un token ERC-20 básico con las funciones esenciales para transferencias y aprobaciones.

Creando un Token ERC-20 con OpenZeppelin

OpenZeppelin es una biblioteca ampliamente utilizada en el desarrollo de smart contracts, ya que proporciona implementaciones seguras y auditadas como el ERC-20. Sus contratos han sido sometidos a rigurosas pruebas de seguridad y auditorías externas, lo que reduce significativamente el riesgo de vulnerabilidades y errores en la implementación.

Usar sus contratos como base simplifica el desarrollo y reduce riesgos de seguridad. Como desarrolladores, podemos aprovechar esta biblioteca para crear un token ERC-20 de manera más eficiente y confiable. Veamos un ejemplo:

pragma solidity ^0.8.0;

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

contract MyToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
        _mint(msg.sender, initialSupply);
    }
}

Aquí estamos heredando de la implementación ERC-20 de OpenZeppelin, lo que nos permite evitar errores comunes y agregar funcionalidades con facilidad.