Forem: Andrés Orozco

Crear fácilmente tokens ERC20

Andrés Orozco — Mon, 09 May 2022 03:43:54 +0000

Apenas voy unos meses aprendiendo de "Blockchain Development" y uno de sus temas apasionantes son los tokens. No voy a ahondar en detalle como estos funcionan, sus varios estándares etc. Esto queda de tarea para el lector, sin embargo, si haré un repaso de como crear un token con el estándar ERC20 de una forma muy sencilla. Antes que nada, si no deseas leer, también dejo un video con toda la guía.

Para este proyecto estaremos usando OpenZepellin. OpenZepellin tiene una serie de productos para crear y manejar contratos, pero en este caso en concreto estaremos usando su librería para crear contratos de manera fácil y segura. La ventaja de OpenZepellin es que este ya tiene implementado distintos estándares como el ERC20 (Fungible Tokens) y ERC721 (NFTs) esto nos ayuda a ahorrar tiempo de desarrollo y nos provee de seguridad para nuestro contrato.

Pre-Requisitos

Tanto OpenZepellin como el framework que usaremos para realizar el deploy del contrato (Truffle), están construidos con JavaScript por lo que necesitaremos de Node para este proyecto. Una vez hayas instalado node abriremos un terminal y escribimos:

node --version

Si la instalación ha sido correcta el comando nos lanzara nuestra versión de node, ahora podremos usar npm (Node Package Manager) para instalar los paquetes necesarios.

Truffle es un framework que nos brinda varias herramientas para manejar nuestros contratos, en este caso lo usaremos para hacer el deploy de nuestro contrato a una red de pruebas:

npm install truffle -g

Ahora crearemos nuestra carpeta del proyecto, puedes ponerle el nombre que desees, por ejemplo crear la carpeta test.

mkdir test

Ahora usando el terminal, entraremos en esta carpeta

cd test

y correremos el comando
truffle init
En el caso de que nos de error, podemos intentar correrlo con el comando npx truffle init

Este comando creara la jerarquía de directorios necesarios para crear nuestro token.
Finalmente usaremos npm para instalar OpenZepellin
npm install @openzeppelin/contracts
Muy bien ahora si ya tenemos todo listo para empezar a crear nuestro token.

Entendiendo OpenZepellin

OpenZeppelin nos provee de varios contratos ya implementados, por ejemplo el contrato ERC20 ya tiene implementado el estándar ERC20 para construir nuestro contrato. Además de esto tenemos extensiones para añadir nuevas características a nuestro contrato.

ERC20Burnable

Nos permite añadir la opción de quemar tokens tanto de nuestra wallet como de la wallet de otros, esto lo puede hacer tanto el dueño de los tokens o aquellos que tengan el permiso, lo mas común es que el owner del contrato tenga estos permisos.

ERC20Capped

Nos permite añadir un límite a la cantidad existentes de tokens.

ERC20Pausable

Nos permite añadir la opción de pausar tanto las transferencias, como el minting y el quemado de los tokens.

ERC20Snapshot

Nos permite implementar mecanismos de snapshot. Cuando creamos la snapshot los balances y el suministro total (total supply) son guardados para que puedan ser accedidos en futuro.

ERC20Permit

Con esta extensión podemos implementar permisos para otras cuentas, por ejemplo para crear varios roles y a que funciones tienen acceso estos roles.

Además de estas extensiones mencionadas, existen otras, que al momento de la creación de este post, siguen estando en versiones de prueba.

Creación del token

OpenZepellin recientemente añadió una nueva herramienta a su suite, se trata de Wizzard esta herramienta nos sirve como un esquema de partida para la creación de tokens mas complejos.
En mi caso el contrato que estaremos creando para nuestro token tendrá la propiedad de crear nuevos tokens (mintable), quemar tokens (burnable) y pausar tanto las transferencias, como la creación y quemado de los tokens (pausable). No nos olvidemos, también, de poner el nombre y símbolo de nuestro token, ademas de una cantidad pre-acuñada (pre-mint) para el deployer del contrato. Con todas estas configuraciones el Wizzard nos generara un código parecido a este:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Moonify is ERC20, ERC20Burnable, Pausable, Ownable {
    constructor() ERC20("Moonify", "MFY") {
        _mint(msg.sender, 1000 * 10 ** decimals());
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Copiamos el código del Wizzard y creamos un nuevo archivo dentro de la carpeta contracts que fue creada por truffle. En mi caso el nombre del archivo es Moonify.sol (extensión de solidity) y dentro de este archivo pegamos el código de nuestro contrato.

Listo con esto quedaría nuestro contrato terminado, a primera vista parece un contrato muy simple. Pero en realidad contiene varias funcionalidades, con las cuales no solo podemos hacer transferencias de nuestro token, si no también, crear más tokens o quemar tokens.
Nota: Si deseas conocer a mas profundidad que hace cada linea del contrato te recomiendo ver mi video tutorial.

Deployment del contrato

Ahora que nuestro contrato esta terminado, nos queda hacer el deploy del contrato para que podamos empezar a hacer uso de nuestro token. En este caso haremos el deploy sobre una test network, ya que en este tipo de redes no necesitaremos de ETHER "real" para pagar los costos de gas, en este caso, estaremos usando la red de Kovan.
Lo primero que haremos es crear una cuenta en infura. Una vez creada la cuenta, nos dirigimos a create new project, le ponemos cualquier nombre y lo importante aquí es copiar el endpoint que empieza por https.

Lo siguiente es crear una wallet en kovan usando metamask, la creacion de la wallet en metamask es sencillo, solo recuerda que una vez tengas tu wallet poner como red Kovan.
IMAGEN

Finalmente, necesitamos es conseguir ETHER, recordando que este ETHER no tiene valor real ya que estamos en una test network. Para esto vamos a la siguiente página: https://faucet.kovan.network/ pegamos nuestra llaves pública y esperamos unos minutos hasta que la transacción haya sido verificada.

Configurar Deployment

Estamos llegando a la parte final, ahora ya solo nos resta configurar el deployment de nuestro contrato, para esto tendremos que instalar una libreria extra con npm, para esto en una terminal escribimos el siguiente comando:

npm i -g hdwallet-provider

Ahora si abrimos nuestro archivo de configuración truffle-config.js con nuestro editor de texto de preferencia y vamos a crear las siguientes variables.

const HDWalletProvider = require("@truffle/hdwallet-provider");
const privateKey = "TU_LLAVES_PRIVADA";
const endpointUrl = "INFURA_ENDPOINT"
/**
* Use this file to configure your truffle project. It's seeded with some...

ahora nos dirigimos a la parte de networks en el archivo de configuración y vamos a definir la red de Kovan

kovan: {
  provider: function() {
    return new HDWalletProvider(
      //private keys array
      [privateKey],
      //url to ethereum node
      endpointUrl
    )
  },
  gas: 8000000,
  gasPrice: 25000000000,
  network_id: 42
},

Ahora necesitamos poner que versión del compilador de solidity deseamos usar.

// Configure your compilers
  compilers: {
    solc: {
      version: "^0.8.1",    // Fetch exact version from solc-bin (default: truffle's version)
      // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
      // settings: {          // See the solidity docs for advice about optimization and evmVersion
      //  optimizer: {
      //    enabled: false,
      //    runs: 200
      //  },
      //  evmVersion: "byzantium"
      // }
    }
  },

Ahora entraremos a la carpeta de migrations y creamos un archivo con el nombre de 2_deploy.js y pegamos el siguiente código.

const contrato = artifacts.require("Moonify"); //require(nombreContrato)

module.exports = async function (deployer) {
    await deployer.deploy(contrato);
}

Con esto hemos finalizado la configuración para el deploy del contrato, se que parece tedioso, pero es un proceso que lo repetirás tanto que ya se hará natural.

Listo! ahora si estamos listos para hacer el deploy de nuestro contrato. Primero vamos a compilar el contrato:

truffle compile

Finalmente vamos a hacer el deploy con:

truffle migrate --network kovan

Si todo ha salido bien has hecho el deploy de tu token ERC20 a la red de Kovan. Felicidades! Recuerda copiar la address de tu token para que la puedas añadir a metamask.

Interactuar con contratos en Ethereum

Andrés Orozco — Mon, 09 May 2022 03:37:00 +0000

En el blog anterior describí como crear un token ERC20 de forma sencilla usando OpenZepellin. Este contrato nos brindaba la posibilidad de acuñar tokens (mint), quemar tokens (burnable) y pausar la transferencia de los tokens (pausable), sin embargo aun no mostré como se puede llamar a las funciones del contrato con estas propiedades. Hoy aprenderemos a hacerlo.

Antes de empezar debemos entender la diferencia entre una call y una transacción.

Call

Cuando hacemos una call ejecutamos código que la blockchain, pero esta ejecución no cambiara ningún dato en la blockchain. Por lo tanto las calls no cuestan ETH, es decir que el principal uso de las calls es para leer datos de la blockchain. En general las calls nos retornan un valor.

Transacción

Por otro lado, las transacciones cambian el estado de la blockchain, es decir, escriben (o cambian) datos de la red. Por lo tanto; las transacciones tienen un costo de gas. En general las transacciones nos retornan una id de transacción.

Es vital conocer esta diferencia tanto cuando programamos contratos inteligentes como cuando queremos obtener o escribir datos en la blockchain.

Interactuar con contratos usando truffle.

Truffle nos brinda la posibilidad de interactuar con los contratos a través de sus abstracciones. Podemos crear estas abstracciones tanto en la consola de desarrollo como creando scripts usando JavaScript.

Consola

Primeramente necesitamos ingresar a la consola de desarrollador espécificando la red en la que hicimos el deploy del contrato.

truffle console --network kovan

La consola de truffle nos permite interactuar con nuestros contratos usando JavaScript. Ahora necesitamos obtener la abstracción de nuestro contrato, si seguiste el tutorial anterior recordaras que el nombre del contrato de mi token ERC20 es Moonify.

truffle(kovan)> let instance = await Moonify.deployed()

Ahora por ejemplo, si llamamos a nuestra variable instance observaremos como nos devuelve la abstracción de nuestro contrato.

truffle(kovan)> instance

Como podrás notar la abstracción del contrato contiene tanto las funciones, variables, eventos y address de nuestro token. Con la abstracción lista ya podemos empezar a usar las funciones de nuestro contrato.

Probemos pausar las transferencias de nuestro token, para esto habiamos creado una función pause que no recibe ningún parametro pero que solo puede ser llamada por el dueño del contrato.

function pause() public onlyOwner {
    _pause();
}

Para llamarla basta con escribir el siguiente comando:

truffle(kovan)> instance.pause()

Ahora por ejemplo si queremos enviar nuestros tokens a otra cuenta usando metamask, veremos que nuestra transacción tendrá un error. De hecho, podemos revisar nuestra transacción fallida en Etherscan y observar que la transacción ha sido revertida y nuestro ETH devuelto.

Por supuesto, para volver a activar las transacciones de nuestro token basta con correr:

truffle(kovan)> instance.unpause()

Como habrás notado hemos llamado solo a funciones que no requiren de parámetros. Nuestra función mint, por ejemplo, require de una address y de una cantidad. Esto tranquilamente lo podríamos hacer desde la consola, pero esto trae muchos incovenientes como andar copiando y pegando distintas address, como también, que una vez cerrado la consola tendriamos que repetir todo este procedimiento. ¿Solución? Crear un script y ejectuarlo con Truffle.

Scripts

Como acabo de mencionar, los scripts nos traen muchas ventajas. Empezemos creado una carpeta llamada scripts, donde hubicaremos los scripts para ser reutilizados.

mkdir scripts

Ahora creemos rápidamente un script que nos permita acuñar tokens para una cuenta. El nombre del script será mint.js, recuerda guardarlo dentro de la carpeta de scripts.

const web3 = require("web3")
var cantidad = 100
var address = "0x8A7320D4E9bcA258E73f8ec61F4e4149f22f6F96"

module.exports = async function main(callback){
    try {
        // Obtenemos la abstracción del contrato
        const contrato = await artifacts.require("Moonify").deployed()
        // Convertimos la cantidad a acuñar en Big Number
        const value = web3.utils.toBN(cantidad * 1e18)
        // Llamamos a nuestra función mint con una address y valor a acuñar
        await contrato.mint(address, value.toString());
        callback(0);
    } catch (error) {
        console.error(error);
        callback(1);
    }
}

El script es bastante sencillo y es una buena base para crear otros scripts para otras funciones. De todas formas he dejado comentarios explicando las lineas mas importantes.

Finalmente, para ejectuar nuestro script:

truffle exec mint.js --network kovan

Si todo ha salido bien habremos acuñado 100 tokens a la cuenta especificada en la variable address.

Conclusiones

Como lo acabamos de observar, interactuar con nuestros contrato es bastante sencillo usando truffle. Cabe aclarar que hemos interactuado con un Token creado por nosotros. Para interactuar con contratos de terceros necesitaremos la ABI del contrato y hacer uso del paquete @truffle/contract. También te invito a estudiar los contratos de OpenZepellin para que puedas llamar a muchas otras funciones, por ejemplo, owner() es una call que nos permite saber el address del dueño del contrato.

Mejora tu productividad como desarrollador: Window Managers

Andrés Orozco — Mon, 09 May 2022 03:26:00 +0000

Probablemente nunca habías escuchado del termino window manger. Y es que la gran mayoría de sistemas operativos y distribuciones de linux usan por defecto desktop enviroments (entornos de escritorio). Estos entornos de escritorio manejan las ventanas apilándolas una encima de otra y a estas ventanas apiladas las podemos mover, cambiar su tamaño, minimizarlas, etc. Es decir, todo el tiempo trabajamos con ventanas flotantes.

¿Qué son?

Por otro lado, como su nombre lo dice, los window managers se dedican exclusivamente al manejo de ventanas y hacen este trabajo de manera diferente. Las ventanas que abrimos son ubicadas de manera automática siguiendo un patrón predefinido, siendo el patrón de tiling window el preferido por muchos. Pero, además de esto, los window managers tienen otras ventajas sobre los típicos entornos de escritorio.

Ventajas de los window managers

Los window managers tienen muchas ventajas sobre su contra parte, aquí mencionare algunas de esas ventajas:

Recursos: Al tener control total sobre nuestro gestor de ventanas, este no carga programas innecesarios de fondo. Esto se traduce a un consumo de recursos muy reducido, tanto es así, que los sistemas que ocupan que ocupan window managers no llegan ni a consumir 500MiB o menos.
Debloated: Los entornos de escritorio vienen con una gran cantidad de aplicaciones adicionales para que puedan funcionar de manera correcta. Programas que muchas veces ni usaremos. Mientras, los window managers no vienen con programas adicionales instalados, quitándonos mucha basura de encima. Es decir, se manejan de manera minimalista.
Facilidad para trabajar con los espacios de trabajo: A pesar de que los entornos de escritorio si nos brindan la opción de crear distintos espacios de trabajo, raramente los usamos ya que no les encontramos motivo alguno. En cambio, los window manager dependen mucho de la creación de distintos espacios de trabajo. Esto nos permite tener todo mas organizado y controlado. Por ejemplo, podemos tener un espacio de trabajo solo para tareas en el navegador, otro para terminales, otro para nuestro IDE, etc.
Programables: Tenemos entornos de escritorio a los que poco se les puede personalizar como el entorno de MacOS o Windows, hasta otros con alto nivel de personalización como Gnome o KDE. Pero los window managers llevan esto a otro nivel, ya que podemos programar cada parte de nuestro window manager para agregar cualquier funcionalidad que literalmente nosotros queramos.
Evitamos el uso del mouse: Seguramente en alguna ocasión te topaste con algún entusiasta de Vim y te explicó que una de sus ventajas es que nunca debes usar el mouse, ya que evitamos perder tiempo con el constante movimiento que hacemos al obtener el mouse. Pues los window managers apuntan a esta misma filosofía. Todo, absolutamente todo, lo podemos hacer con atajos de teclado, haciendo que usemos el mouse la menor cantidad de tiempo posible. Por ejemplo, en awesomeWM nos movemos con las mismas teclas con las que navegamos en Vim (h,j,k y l).

Desventajas

Por supuesto todo lo bueno viene con un costo a pagar. Y es que los window manager tienen unas pequeñas desventajas que tal vez nos desmotiven a intentar usarlos, pero si te gusta aprender y tienes el tiempo para hacerlo estas desventajas desaparecerán con el tiempo.

Alta curva de aprendizaje: Alguna vez intentaste aprender vim y terminaste frustrado por su curva de aprendizaje? Pues con los window managers puede ser parecido, a pesar de que muchos de ellos vienen ya con una configuración inicial, configurarlos a nuestra medida implica aprender el lenguaje de programación en el que estos son programados, además de su API para poder entender que podemos y no podemos hacer.
Memorizar los atajos de teclado: Cuando uno esta acostumbrado a usar el mouse como su herramienta principal, empezar a aprender atajos de teclado parece algo tedioso. Pero creeme que aprender atajos de teclado vale la pena, ya sean atajos de tu gestor de ventanas o aplicaciones, invierte algo de tiempo en aprenderlos. El tiempo que invertimos en aprender atajos de teclado lo recuperaremos en un futuro. Ya que tareas que costaban unos cuantos clicks, ahora las haremos con un solo atajo de teclado.

Conclusiones

Como puedes observar son pocas las desventajas, desventajas que con el paso del tiempo son reducidas. Pero tengo ser sincero en este aspecto, si no posees del tiempo para configurar y aprender a usar un gestor de ventanas lo mejor es que consideres no intentarlo. Pero si te gusta aprender nuevas herramientas, te preocupa la organización y productividad de tu espacio de trabajo, y sobre todo tienes el tiempo para llevar el gestor de ventanas a tu medida, te recomiendo que lo intentes. Es algo de lo que no te arrepentirás, ya que este cambia totalmente la manera en la que usas tu computador, y una vez lo domines no hay vuelta atrás.

Recursos

Te dejo unos cuantos recursos para que puedas empezar a probar con window managers.