Votación con contratos inteligentes en Remix

0
613

Índice

  1. Introducción
  2. Contratos inteligentes
  3. Tipos de lenguajes
  4. Usando el lenguaje Solidity
  5. Entendiendo el ejemplo Ballot (votaciones)
  6. Entendiendo como funciona el código de la votación
  7. Votación paso a paso
  8. Limitaciones
  9. Conclusión

Introducción

Este es el tercer tutorial sobre criptomonedas donde vamos a ver cómo empezar con contratos inteligentes y el IDE Remix. Si te apetece, antes de seguir, puedes revisar las publicaciones anteriores a ésta; aquí tienes los enlaces:

Cómo comprar e invertir criptomonedas en Binance: https://www.adictosaltrabajo.com/2022/01/14/como-comprar-e-invertir-criptomonedas-en-binance/

Entendiendo las criptomonedas: https://www.adictosaltrabajo.com/2022/01/24/entendiendo-las-criptomonedas/ 

Usando la wallet MetaMask y la red local Ganache: https://www.adictosaltrabajo.com/2022/02/09/usando-la-wallet-metamask-y-la-red-local-ganache/

Compilación y despliegue de contratos inteligentes con Truffle y Ganache: https://www.adictosaltrabajo.com/2022/02/16/compilacion-y-despliegue-de-contratos-inteligentes-con-truffle-y-ganache/

Creando tokens Ethereum: https://www.adictosaltrabajo.com/2022/03/14/creando-tokens-ethereum/

He de recordaros que estoy compartiendo simplemente lo que voy aprendiendo, así que solo os ofrezco mi proceso de aprendizaje y exploración, por si os ayuda, no la visión de un experto.

Recapitulando un poco las opciones de “intentar” ganar dinero con criptomonedas puedes: comprarlas y venderlas más caras (especular), invertir con ellas (staking o depósitos), crear una criptomoneda (clonar y/o crear una red propia por lo que serías el dueño inicial de las monedas y convencer a gente para que compre), adquirir y vender tokens (de esto ya hablaremos otro día), minar una red existente (contribuir en las pruebas de esfuerzo) o también puedes vender servicios de desarrollo de software (que es a lo que me dedico). Podrías ser programador de contratos inteligentes que auguro que existirá una alta demanda y bien pagada, como de todo lo sofisticado, aunque este mundo cambie mucho en los próximos años.

Sigo insistiendo que antes de invertir en criptomonedas seas muy consciente que puedes perder todo el dinero que metas, así que ojito. Con esto de los contratos pasa lo mismo, si los haces mal puedes perder mucho dinero (o hacérselo perder a otros) aportando poco valor por lo que no parece mala idea tener cerca a gente que realmente sepa.

Contratos inteligentes

Un contrato inteligente “a grandes rasgos” es una porción de código que vincula a dos (o más) partes, y que es almacenado y ejecutado dentro de la red de bloques encadenados. Para que no se inunde la red de bloques de porciones de código se establece que la ejecución tiene un coste llamado gas.

Por tanto, un contrato inteligente tiene un ciclo de vida. Este se puede resumir en: negociación contractual clásica (fuera del código), transcripción a código de las condiciones contractuales (no se os olviden los test), compilación y depuración, optimización (que consuma el menor gas posible), revisión de seguridad (se puede liar una gorda porque el código estará visible para toda la cadena, aunque sea en byte code, en versión compilada), despliegue en la red y su congelación (aceptación por la mayoría de los nodos de la red), ejecución (siendo consciente del coste en gas), actualización del estado de los activos (principalmente la transferencia de criptomonedas o el registro de datos persistentes) y desactivación.

Esto tiene su tela, por lo que os sugiero ser pacientes (me está costando encontrar un sitio donde leerlo ordenadamente). He encontrado un artículo muy interesante que os recomiendo: An Overview on Smart Contracts: Challenges, Advances and Platforms https://www.henrylab.net/wp-content/uploads/2019/12/SmartContractFGCS__arXiv_.pdf

Captura de: An Overview on Smart Contracts: Challenges, Advances and Platforms https://www.henrylab.net/wp-content/uploads/2019/12/SmartContractFGCS__arXiv_.pdf

Si queremos programar, lo primero que deberíamos hacer es visitar una de las fuentes sobre los contratos inteligentes en Ethereum: https://ethereum.org/es/developers/docs/smart-contracts/

Tipos de lenguajes

Podemos ver que un contrato inteligente se construye con un lenguaje llamado “Solidity”. Si estás acostumbrado a programar en otros lenguajes veréis que es bastante intuitivo: altamente tipado, orientado a objetos…

Captura de pantalla de la página https://ethereum.org/es/developers/docs/smart-contracts/

Es más, tenemos otros lenguajes alternativos (https://ethereum.org/es/developers/docs/smart-contracts/languages/). Existe otro lenguaje llamado Vyper, más orientado a programadores Python (más complejo y con más control sobre el gas gastado) e incluso un tercero llamado Yul. Obviamente tendríamos que empezar por el entorno más sencillo y descriptivo antes de plantearnos trabajar con lenguajes más complejos.

En la propia documentación podéis encontrar comparativas sobre los lenguajes:

Captura de imagen comparando Solidity, Vyper y Yul/Yul+.

Usando el lenguaje Solidity

Vamos a empezar por el lenguaje aparentemente más sencillo: Solidity. 

Parece lógico que, si vamos a programar, lo primero que intentemos conseguir es un entorno de desarrollo con el que nos podamos encontrar cómodos y revisar la documentación del lenguaje https://docs.soliditylang.org/en/latest/.

Captura de pantalla de la documentación de Solidity.

También he encontrado un libro con la documentación de Solidity en formato pdf: https://buildmedia.readthedocs.org/media/pdf/solidity/develop/solidity.pdf

Vamos a revisar el entorno de desarrollo Remix y ver los ejemplos que vienen por defecto. No hay que instalar nada y basta con visitar https://remix.ethereum.org/. Yo empecé a jugar con el navegador Safari en Mac y no me funcionaba demasiado bien (no me permitía cambiar el nombre de ficheros). He pasado a Chrome y parece que me funciona mejor. Os recomiendo que reviséis que el ordenador y navegador están actualizados a las últimas versiones.

Captura de pantalla de la página inicial de Remix.

Este es el aspecto de una fuente básica en Solidity:

En el lateral izquierdo vemos las opciones disponibles. La primera es la de revisión de ficheros.

Captura del navegador de ficheros de Remix y del primer esqueleto de contratos inteligentes.

La segunda opción es la de compilación. Podemos pulsar compilar y ver el resultado. Es sorprendentemente lo descriptivo del entorno cuando hay un error.

Captura de pantalla del la sección de compilación de remix.

La siguiente opción es ejecución. Podemos elegir el entorno.

Captura de pantalla del selector de entorno de ejecución.

También disponemos de una lista de cuentas y el Ether disponible. 

La cuenta que lance el contrato verá disminuido el gas.

Captura de pantalla de las cuentas y Ether disponible.

Al pulsar deploy veremos cómo aparecen los métodos disponibles. En nuestro ejemplo tan simple veremos que podemos invocar a Store y Retrieve (almacenar y recuperar).

Captura de pantalla donde se vean las opciones de Deploy y los botones con las invocaciones a los métodos.

Podemos comprobar cómo disminuye nuestra cantidad de moneda en cada invocación.

Captura de pantalla visualizando que el Ether se ha consumido.

También podremos observar que las consultas sin operativa (view o vista) no consumen Ether.

Captura de pantalla donde se visualiza) el retorno del resultado almacenado y recuperado.

Con esto ya tenemos lo básico, aunque debemos recorrer el sistema de ficheros para entender el resto de los elementos y ejemplos. 

Cuando se trabaja medianamente bien, primero se programan los test de un sistema y los test nos demandan las funciones que tenemos que crear (leed un poquito sobre TDD, si no os es familiar).

Entendiendo el ejemplo Ballot (votaciones)

En el ejemplo de Ballot (votaciones) podemos descubrir estos conceptos y algunos más completos. Os recomiendo este tutorial (realmente es una cadena de tutoriales): https://medium.com/coinmonks/voting-on-a-blockchain-how-it-works-3bb41582f403

En otros tutoriales ya lo haremos paso a paso (empezar por el test) pero ahora solo vamos a tratar de entender el código de votaciones.

Primero veamos el código del test:

Inicialmente se importa el fichero de remix_tests.sol que es el fichero de soporte donde están los métodos para las comprobaciones. 

Captura de pantalla de remix_tests.sol

Luego se importa el fichero ../contracts/3_Ballot.sol donde se encuentran nuestras fuentes reales que queremos comprobar (el contrato inteligente en sí). El test es un poquito pobre porque sólo verifica una funcionalidad base. 

Captura de pantalla con el fuente ../contracts/3_Ballot.sol

El test crea un array de candidatos propuestos (bytes32[] proposalNames).

Posteriormente, antes de la ejecución de los test (beforeAll), se crea el objeto Ballot (votación, ballotToTest = new Ballot(proposalNames)) inicializándolo con el elemento “candidato1” (proposalNames.push(bytes32(«candidate1”))).

Al lanzarse el test (se ejecutan todos los métodos que comienzan con check).

Dentro del test se vota al primer candidato (del índice 0, ballotToTest.vote(0)) y se verifican las propuestas y el ganador de la votación.

Para poder ejecutar la aplicación de votaciones con normalidad desde el entorno, tenemos que hacer una pequeña cosa que no he visto evidente en los manuales, que es hacer un deploy con unos datos iniciales. 

Si nos fijamos en el código el constructor de la clase requiere un array de nombres de las opciones a votar:

Escribimos los datos de las tres opciones (ya nos preocuparemos en otro tutorial, invocándolo desde Java Script, de que sean datos legibles).

Ver referencia: https://ethereum.stackexchange.com/questions/50310/how-to-pass-the-value-in-bytes32-array.

Captura de pantalla del fichero auxiliar creado para tener a mano los datos de inicialización

Con esto, ya podemos lanzar el contrato de votaciones y cacharrear.

Captura de pantalla con las opciones disponibles del contrato.

Si vemos el análisis de código estático es un poco preocupante, lo que significa que tenemos todavía mucho que estudiar.

Captura de pantalla del panel de análisis estático de código con advertencias importantes sobre el posible consumo infinito de gas.

Entendiendo como funciona el código de la votación

He traducido los comentarios en el código para que sea más comprensible.

¿Cómo funciona la votación? 

El chairman (el jefe) arranca el contrato proponiendo las opciones a votar.

Se inicializa el contrato y se añade la lista de votantes.

Cada votante vota o delega el voto (solo tenemos que cambiar la cuenta activa que llama a la función).

Superado el tiempo de votación se contabiliza el resultado total (en este ejemplo no hay tiempo máximo).

El contrato inteligente se desactiva pasado ese momento quedando la información invariable en el tiempo (tampoco lo cubre en este ejemplo).

Votación paso a paso

Veamos paso a paso como se hace en las pantallas, que al principio puede parecer un poco confuso:

Necesitamos unas opciones de votación y elegir un Chairman (la cuenta con la que hace el Deploy). 

En cuentas pinchamos sobre el primer elemento y copiamos las otras tres primeras cuentas del fichero auxiliar y las pegamos en la opción de Deploy.

Captura de pantalla donde vemos la primera cuenta y el fichero auxiliar con los datos.

Tenemos que recordar que nuestro Chairman termina en C4 para ir siguiendo el ejemplo. Pulsamos el botón de deploy.

Captura de pantalla con el contrato desplegado y las opciones visibles.

Podemos ver en la consola el resultado de la transacción, el gas gastado y otros elementos.

Captura de pantalla de la consola.

Ahora tenemos que, con la cuenta del Chairman seleccionada, dar el derecho de voto a los votantes que queramos (las otras cuentas que tenemos registradas. Estas son las cuentas que usaremos:

Vamos cambiando el valor de giveRigthToVote a las otras tres cuentas sucesivamente y haciendo la llamada.

Captura de pantalla dando derecho a voto a los distintos participantes.

Y repetimos con las tres cuentas.

Captura de pantalla de la consola con las tres cuentas asignadas.

Ahora cambiamos de cuenta a la que termina en b2 y en delegar (Delegate) elegimos la terminada en db:

Captura de pantalla con otra cuenta seleccionada y delegando un voto a otra.
Captura de pantalla del resultado de la delegación.

Ahora que ya tenemos dados de alta los votantes, y las delegaciones, volvemos a elegir una a una las cuentas y votamos la opción por índice: la 0, 1 o 2.

Si elegimos una cuenta de invocación delegada nos dará error diciendo que no se puede votar.

Esta es las salida que nos encontramos.

Captura de pantalla del error al tratar de delegar una cuenta delegada.

Ya solo nos queda convocar a la función winnerName y vemos debajo el nombre de la opción ganadora.

Captura de pantalla con la opción winnerName activada y viendo el resultado generado.

Y esta es la salida.

Captura de pantalla de la salida de la invocación a winnerName.

Podéis leer artículos interesantes sobre las limitaciones de esta votación en: https://medium.com/coinmonks/voting-on-a-blockchain-solidity-contract-codes-explained-c677996d94f2

Limitaciones

Algunas posible limitaciones son: ser un punto simple de fallo, la capacidad de consumir el gas sin terminar con gran número de votantes, consumo infinito de gas, el posible problema de tiempo de espera (concurrencia), etc.

Captura de https://medium.com/coinmonks/voting-on-a-blockchain-solidity-contract-codes-explained-c677996d94f2 explicando las limitaciones del ejemplo.

Conclusión

Como podéis comprobar, la construcción de contratos inteligentes no es algo trivial. Solo hemos escarbado un poquito y todavía lo estamos haciendo mal (el ejemplo no es muy completo) y estamos trabajando en un único IDE simulando todo.

En siguientes tutoriales tendremos que ir viendo otros componentes de la arquitectura como serán monederos externos, simuladores de red de cadenas de bloques, optimizados, etc.

Para complementar este tutorial os dejo algunos recursos muy interesantes para continuar la formación:  

https://yos.io/2019/11/10/smart-contract-development-best-practices/

https://www.youtube.com/watch?v=JP-dzoDmJFw

https://www.youtube.com/watch?v=coQ5dg8wM2o

https://cryptotechuniversity.org/coins/el-ciclo-de-vida-de-los-contratos-inteligentes-en-el-ecosistema-blockchain/

 

Dejar respuesta

Please enter your comment!
Please enter your name here