Quicknode

29 de mayo de 2019 — 7 minutos de lectura

Creación de contratos inteligentes de Solidity actualizables

Introducción a Zeppelin OS

Zeppelin se dedica por completo al desarrollo de contratos inteligentes. El equipo ha ayudado a muchos desarrolladores a crear contratos inteligentes con openzeppelin-solidity, una de las bibliotecas web3 más descargadas en NPM (¡con más de 10 000 descargas cada semana!). Según la página web de Zeppelin:

¿Qué problema resuelve?

ZeppelinOS ayuda a los desarrolladores a crear contratos inteligentes actualizables mediante bibliotecas que cualquiera puede utilizar en la Ethereum . A diferencia de los contratos tradicionales (que pueden quedar congelados para siempre en la cadena de bloques, con errores, funcionalidades limitadas, etc.), ZeppelinOS permite a los usuarios optar por permitir las actualizaciones de los contratos, lo que abre las puertas a un proceso más sostenible para el desarrollo de proyectos web3 basados en cadenas de bloques. Gracias a las actualizaciones, podemos realizar lanzamientos iterativos, añadir rápidamente pequeñas funcionalidades (que podemos ajustar según los objetivos siempre cambiantes de nuestros usuarios) y, por supuesto, podemos implementar correcciones para los errores que hayamos introducido en iteraciones anteriores.

Desarrollo con ZeppelinOS

¡Vamos a crear un contrato CrudApp actualizable! Vamos a implementar CrudApp.sol y luego actualizarlo conservando sus datos… así que empecemos:

1- Crear un proyecto e instalar las dependencias

mkdir crud
cd crud
npm init
npm install --global zos

2- Inicializa tu proyecto

zos init crud

Este comando creará un zos.json archivo, que contiene toda la información sobre el proyecto. Para obtener más detalles sobre este archivo, consulta el archivos de configuración página.

El comando también inicializará Trufa. Así que, a estas alturas, dentro del puaj En ese directorio deberías tener un package.json archivo (creado por npm), dos directorios vacíos llamados contratos y migraciones, un truffle-config.js archivo (creado por zos para Truffle), y un zos.json archivo (creado por zos (para ZeppelinOS).

3- Añadir el contrato CrudApp.sol

Añadamos ahora nuestro archivo CurdApp.sol. Vamos a realizar algunos cambios en nuestro contrato inteligente anterior, así que veamos en qué consisten:

pragma solidity ^0.4.23;

contract CrudApp {
    
   struct country{
      string name;
      string leader;
      uint256 population;
   }
  
   country[] public countries; 

   uint256 public totalCountries;
  
  
    constructor() public {
       totalCountries = 0;
   }

   event CountryEvent(string countryName , string leader, uint256 population);
   
   event LeaderUpdated(string countryName , string leader);

   event CountryDelete(string countryName);

    
   function insert( string countryName , string leader , uint256 population) public returns (uint256 totalCountries){
        country memory newCountry = country(countryName , leader, population);
        countries.push(newCountry);
        totalCountries++;
        //emit event
        emit CountryEvent (countryName, leader, population);
        return totalCountries;
   }
   
   function updateLeader(string countryName, string newLeader) public returns (bool success){
       //This has a problem we need loop
       for(uint256 i =0; i< totalCountries; i++){
           if(compareStrings(countries[i].name ,countryName)){
              countries[i].leader = newLeader;
              emit LeaderUpdated(countryName, newLeader);
              return true;
           }
       }
       return false;
   }
   
   function deleteCountry(string countryName) public returns(bool success){
        require(totalCountries > 0);
        for(uint256 i =0; i< totalCountries; i++){
           if(compareStrings(countries[i].name , countryName)){
              countries[i] = countries[totalCountries-1]; // pushing last into current arrray index which we gonna delete
              delete countries[totalCountries-1]; // now deleteing last index
              totalCountries--; //total count decrease
              countries.length--; // array length decrease
              //emit event
              emit CountryDelete(countryName);
              return true;
           }
       }
       return false;
   }
   
     
   function getCountry(string countryName) public view returns(string name , string leader , uint256 population){
        for(uint256 i =0; i< totalCountries; i++){
           if(compareStrings(countries[i].name, countryName)){
              //emit event
              return (countries[i].name , countries[i].leader , countries[i].population);
           }
       }
       revert('country not found');
   }     
   
  function compareStrings (string a, string b)  internal pure returns (bool){
       return keccak256(a) == keccak256(b);
   }
   
   
   function getTotalCountries() public view returns (uint256 length){
      return countries.length;
   }
}

Eliminar el constructor y añadir un inicializador

«Puedes utilizar tus contratos de Solidity en ZeppelinOS sin necesidad de realizar modificaciones, salvo en lo que respecta a sus constructores. Debido a un requisito del sistema de actualizaciones basado en proxies, no se pueden utilizar constructores en los contratos actualizables. Puedes consultar con más detalle los motivos de esta restricción en la página «Patrón de actualizaciones de ZeppelinOS».»

Esto significa que, al utilizar un contrato en ZeppelinOS, debes convertir su constructor en una función normal, que suele llamarse inicializar, donde se ejecuta toda la lógica de configuración:

function initialize(uint256 countryLimit) initializer public {
   totalCountries = 0;
   limit = countryLimit;
}

Tienes que importar Initializable.sol además, para que esto funcione:

import "zos-lib/contracts/Initializable.sol";

Instala Ganache e implementa tu proyecto

Utilizaremos Ganache (una cadena de bloques local) para implementar nuestro contrato inteligente. Puedes modificar la configuración de la red en truffle-config.js Si quieres utilizar otra red, abre otro terminal y ejecuta los siguientes comandos:

npm install -g ganache-cli --port 9545 --deterministic

Ahora vuelve a la terminal anterior y ejecuta los siguientes comandos para iniciar una sesión. Estamos utilizando --red opción para la red local y --de [dirección] para proporcionar una Ethereum (que vamos a utilizar para implementar el contrato inteligente). Estamos utilizando una dirección predeterminada de Ganache (puedes verla en la terminal de Ganache) y también estamos utilizando una caduca parámetro para definir el número de segundos durante los que será válida esta sesión (1 hora en este caso).

zos session --network local --from 0x1df62f291b2e969fb0849d99d9ce41e2f137006e --expires 3600

Ahora vamos a implementar nuestro proyecto:

zos push

Este comando implementa CrudApp a la red local e imprime su dirección. Puedes implementar más contratos utilizando añadir comando y también se implementarán tras este comando.

El empujar El comando también crea un zos.dev-<network_id>.json archivo con toda la información sobre tu proyecto en esta red concreta, incluidas las direcciones de las implementaciones de los contratos desplegados en contratos["MyContract"].dirección. Puedes obtener más información sobre este formato de archivo en la archivos de configuración sección.

Actualizar el proyecto

empujar El comando implementa contratos lógicos que no están pensados para ser utilizados directamente, por lo que necesitamos una instancia actualizable (hablaremos de los contratos lógicos y Página de patrones de actualizaciones de ZeppelinOS (en nuestras próximas entradas del blog).

Ahora vamos a crear una instancia actualizable de nuestro CrudApp.sol:

zos create CrudApp --init --args 200

El zos crear El comando admite opciones --init [nombre-de-función] junto con el nombre de la función (que es inicializar (en nuestro caso). También puedes pasar argumentos a esta función (que en nuestro caso es 200, el límite de países). Esto también mostrará una dirección de contrato inteligente, que utilizaremos al interactuar con él.

Interacción con el contrato

Ahora vamos a interactuar con nuestro contrato e introducir algunos países. Para acceder a la consola de Truffle, ejecuta el siguiente comando:

npx truffle console --network local

Ahora verás la consola de Truffle. Vamos a ejecutar algunos comandos e introducir algunos países:

truffle(local)> crud = CrudApp.at('<your-contract-address>') 
truffle(local)> crud.limit()
truffle(local)> crud.insert("USA", "Elizabeth Warren", 33000000)
truffle(local)> crud.getCountry("USA")
truffle(local)> crud.getTotalCountries()

Hemos añadido una entrada a nuestro contrato inteligente. ¡Actualicemos nuestra CrudApp!

Añadir una función

Vamos a añadir una función adicional al final de nuestro contrato inteligente y a actualizarlo. Así pues, por ahora, ya tenemos un getCountry() función… vamos a añadir una más getLeader() función de nuestro contrato inteligente.

function getLeader(string leaderName) public view returns(string name , string leader , uint256 population){
        for(uint256 i =0; i< totalCountries; i++){
           if(compareStrings(countries[i].leader, leaderName)){
              //emit event
              return (countries[i].name , countries[i].leader , countries[i].population);
           }
       }
       revert('Leader not found');
   }

Ahora vamos a actualizar nuestro contrato inteligente. Para ello, tenemos que ejecutar los siguientes comandos:

zos push
zos update CrudApp

Esto generará una nueva dirección de contrato inteligente que utilizaremos para probar nuestro contrato actualizado.

Pruebas del contrato inteligente actualizado

Ahora probemos nuestro contrato inteligente. Debería conservar nuestros datos anteriores y podremos acceder a nuestros nuevos getLeader() función. Así que volvamos a interactuar con nuestro contrato inteligente:

truffle(local)> crud = CrudApp.at('<your-contract-address>') 
truffle(local)> crud.limit()
truffle(local)> crud.getTotalCountries()
truffle(local)> crud.getLeader("Elizabeth Warren")

Podrás comprobar que el contrato inteligente se ha actualizado igual que cualquier otro fragmento de código. 🍰 — ¡En nuestro próximo artículo crearemos un token ERC-20 actualizable!

Conclusión

Aunque parezca bastante sencillo, hay que tener mucho cuidado al utilizar ZeppelinOS debido a la gestión del almacenamiento de Solidity. Aquí puedes consultar los aspectos a los que debes prestar especial atención al actualizar tu contrato inteligente. ¡ZeppelinOS supone un gran valor añadido para el Ethereum !

Dinos qué te gustaría aprender en la sección de comentarios.👇

¿Necesitas ayuda con tu proyecto o tienes alguna duda? Ponte en contacto con nosotros a través de este formulario, en Twitter Quicknode o envíanos un mensaje en Discord.