Creando dApps usando Truffle Framework

Las dApps ( Aplicaciones Descentralizadas ) son aplicaciones que no dependen de servidores tradicionales. En cambio, las dApps utilizan Blockchain para alojar los datos almacenados tradicionalmente en los servidores. Los datos se almacenan a través de la red de Nodes conectados a Blockchain. Se utilizan varias herramientas y marcos para escribir aplicaciones descentralizadas de pila completa. Uno de esos marcos populares para escribir dApps utilizando el lenguaje de programación Solidity es Truffle . Truffle proporciona un andamiaje básico para diseñar proyectos de dApp. Con Truffle, podemos crear los contratos inteligentes necesarios para crear la funcionalidad de la string de bloques, escribir pruebas unitarias para las funciones y diseñar el diseño frontal de la dApp. 
Los pasos básicos para diseñar una dApp full-stack son los siguientes: 
 

Fig 01: Una secuencia de pasos que se siguen en general para escribir dApps

Paso 1: Configuración del entorno de desarrollo: Los requisitos antes de iniciar un proyecto de Truffle son los siguientes: 

• Node.js
• Ganache — Para simular una Blockchain localmente.
• Metamask: para manejar transacciones de Blockchain a través del navegador.

Para configurar el marco de Truffle, ejecute el siguiente comando:

npm install -g truffle

A los efectos del desarrollo, en lugar de utilizar la string de bloques real de Ethereum, confiamos en el uso de una red de prueba o una string de bloques privada local. Para simular un Ethereum Blockchain localmente en su computadora, puede usar Ganache . Ganache, una vez instalado, se puede usar a través de la línea de comandos o usando la GUI provista. Con Ganache, obtiene un conjunto de cuentas de prueba, cada una con hasta 100 Ether de forma predeterminada, para el proceso de desarrollo. 
 

Paso 2: use un Truffle Box para generar código repetitivo: para simplificar el proceso de creación de una dApp en Truffle, en lugar de crear manualmente los archivos e incluir las dependencias, puede usar un Truffle Box . Una caja de trufas proporciona un código repetitivo útil con el que puede comenzar directamente a diseñar su dApp. Estas «cajas» también contienen otros componentes útiles, como Solidity Contracts, bibliotecas, vistas frontales, etc. de uso común. Según los requisitos de su proyecto, puede elegir una caja de trufas de su sitio web oficial . 
 

truffle unbox pet-shop
truffle unbox react

Paso 3: escribir los contratos inteligentes de Solidity: una vez que se descarga y se desempaqueta una caja de trufas, se crea una estructura de directorio específica de Truffle. La estructura general de un proyecto Trufa se muestra en la siguiente figura:
 

Fig. 02: Estructura del directorio de trufas

• El directorio de contratos, todos los contratos inteligentes de Solidity se escriben y almacenan como archivos .sol.
• El directorio de migraciones contiene código para migrar e implementar los contratos diseñados.
• El directorio node_modules almacena todas las dependencias de Node requeridas para ejecutar el proyecto.
• El directorio src se utiliza para almacenar los componentes frontales del proyecto, como archivos HTML y CSS.
• El directorio de prueba almacena las pruebas unitarias escritas por el desarrollador.

El primer paso, por lo general, es diseñar el contrato y guardarlo como archivo .sol en el directorio de contratos. A continuación se muestra un ejemplo simple de un contrato inteligente de Solidity:
 

pragma solidity ^0.4.4;
  
contract TestContract {
  uint my_id;
  
  function setId(uint x) public {
    my_id = x;
  }
  
  function getId() public view returns (uint) {
    return my_id;
  }
}

Paso 4: compilar y migrar los contratos: una vez que se han escrito los contratos, podemos compilarlos y luego migrarlos para almacenarlos en nuestra string de bloques. Para compilar un contrato de Solidity en Truffle, ejecute el comando 

truffle compile

Una vez compilados con éxito, los contratos se convierten en un código de bytes que ejecuta la máquina virtual Ethereum (EVM). Después de una compilación exitosa, los contratos deben guardarse en Blockchain para que los usuarios puedan acceder a las funciones proporcionadas por el contrato. Una vez que se migró a Blockchain, a cada contrato implementado se le asigna una dirección única para hacer referencia a su ubicación en Blockchain. Cuando un usuario desea llamar a funciones desde un determinado contrato implementado, debe invocar las funciones correspondientes a la dirección de los contratos implementados en la string de bloques.
Para especificar qué contratos se deben migrar, debemos especificar sus referencias en el directorio de migraciones dentro de un nuevo archivo. El archivo se llama «2_deploy_contracts.js» y está estructurado de la siguiente manera
 

// Instantiating the compiled contract to be deployed
var TestContract = artifacts.require("TestContract ");
  
module.exports = function(deployer) {
  
  // Deploying the contract to the blockchain
  deployer.deploy(TestContract);
};

Esto es seguido por la ejecución del comando: 

truffle migrate

Nota: Dado que estamos simulando la string de bloques localmente en Ganache, el servicio de Ganache debería estar ejecutándose antes de realizar las migraciones. 
 

Paso 5: Escribir pruebas unitarias: aunque el desarrollo basado en pruebas es un enfoque muy recomendado en todos los ámbitos del desarrollo de software. Es de suma importancia en el caso de las dApps. Por el diseño de la string de bloques, los cambios una vez realizados en la string de bloques se almacenan de forma permanente e inmutable en la string. Por lo tanto, si un desarrollador implementó un contrato con errores en la string de bloques, el contrato se volvería irreparable una vez migrado. La única forma de corregir errores es crear un nuevo contrato, implementarlo y migrarlo a una nueva dirección y solicitar a todos los usuarios que usen la nueva dirección en lugar de la dirección anterior del contrato con errores. Por lo tanto, se deben realizar pruebas consistentes en el desarrollo de dApp.
Todos los archivos de prueba se escriben y almacenan en el directorio de prueba. Las pruebas unitarias en Truffle se pueden realizar con la ayuda de las bibliotecas Chai y Mocha, que proporcionan una variedad de aserciones y otras herramientas para realizar pruebas. Una vez escritas, las pruebas se ejecutan ejecutando

truffle test

Fig. 03: Tech Stack utilizado para desarrollar dApps con Truffle y web3js

Paso 6, 7: creación de una interfaz de usuario e integración con los contratos: el diseño de la interfaz de usuario de la dApp se realiza como de costumbre utilizando herramientas y lenguajes como HTML, CSS, Bootstrap, JavaScript, etc. Para conectar la interfaz con los contratos implementados, confiamos en en la biblioteca JavaScript web3. Usando web3js, podemos instanciar los contratos de Ethereum implementados dentro de un archivo JS de front-end y, posteriormente, llamar a funciones e intercambiar datos con la string de bloques. El código para inicializar web3js e instanciar el contrato implementado es el siguiente:

App = {
  web3Provider: null,
  contracts: {},
  init: async function() {
    return await App.initWeb3();
  },
  
  initWeb3: async function() {
    if (window.ethereum) {
      App.web3Provider = window.ethereum;
      try {
        await window.ethereum.enable();
      } catch (error) {
        console.error("User denied account access")
      }
    }
    else if (window.web3) {
      App.web3Provider = window.web3.currentProvider;
    }
    else {
      App.web3Provider = new Web3.providers
        .HttpProvider('http://localhost:7545');
    }
    web3 = new Web3(App.web3Provider);
    return App.initContract();
  },
  
  initContract: function() {
    $.getJSON("TestContract.json", function(data) {
      var TestContractArtifact = data;
      App.contracts.TestContract = 
        TruffleContract(TestContractArtifact);
          
      App.contracts.TestContract
        .setProvider(App.web3Provider);
    });
    return App.callFunctionFromContract();
  },
  
  callFunctionFromContract: function() {
    App.contracts.TestContract.deployed()
      .then(function(instance) {
      console.log(instance.getId());
    }
  }
};

Para interactuar con la string de bloques y realizar transacciones a través de un navegador web, necesitamos una extensión de navegador capaz de manejar dichas transacciones. Para ello, una opción popular es MetaMask . Una vez que se configura la cuenta de MetaMask, cada vez que se realiza una transacción en la string de bloques, MetaMask muestra un mensaje que detalla la transacción solicitada, junto con el precio del gas y cualquier otra cantidad de Ether que deba enviarse 
con esto, podemos configurar una dApp que se ejecute en la string de bloques local de Ganache.