html

Punto 2.3 Configuración de herramientas y entorno

Para desarrollar contratos inteligentes con Solidity, es crucial configurar nuestras herramientas y entorno de desarrollo correctamente. Esto incluye instalar y configurar un entorno de desarrollo integrado (IDE), instalar herramientas de línea de comando y configurar una red blockchain de prueba. A continuación, detallamos cada uno de estos pasos de manera exhaustiva.

Entorno de Desarrollo Integrado (IDE)

Visual Studio Code (VSCode) es uno de los IDEs más populares para desarrollar en Solidity. Para configurarlo, necesitamos instalar algunas extensiones específicas.

1. Instalar Visual Studio Code desde: https://code.visualstudio.com/
2. Instalar la extensión Solidity en VSCode:
   • Abrir VSCode.
   • Ir a la barra lateral de extensiones y buscar Solidity.
   • Instalar la extensión desarrollada por Juan Blanco.

Instalación de Node.js y npm

Node.js y npm son necesarios para manejar paquetes y dependencias. Para instalarlos:

1. Descargar e instalar Node.js desde: https://nodejs.org/
2. Verificar la instalación abriendo una terminal y ejecutando:

         node -v
         npm -v
       

Truffle Suite

Truffle es un entorno de desarrollo que facilita el manejo y la migración de contratos inteligentes Solidity. Para instalar Truffle:

1. En la terminal, ejecutar:

         npm install -g truffle
       

2. Para verificar la instalación, ejecutar:

         truffle version
       

Ganache

Ganache es una blockchain personal que se puede usar para ejecutar pruebas, comandos y revisar el estado mientras se desarrolla. Ganache puede ser instalado como una aplicación de escritorio o a través de npm.

• Para instalar Ganache desde la página oficial:
  • Ir a https://www.trufflesuite.com/ganache
  • Descargar e instalar la aplicación correspondiente a su sistema operativo.
• Para instalar Ganache-CLI con npm:

        npm install -g ganache-cli
      

Configurando un Proyecto Truffle

Con Truffle y Ganache instalados, podemos iniciar un proyecto Truffle y conectar Ganache como nuestra red de desarrollo local.

1. Crear un directorio para el proyecto y entrar en él:

         mkdir my-solidity-project
         cd my-solidity-project
       

2. Inicializar el proyecto Truffle:

         truffle init
       

3. Configurar el archivo truffle-config.js para conectarse a Ganache. Asegúrate de que Ganache esté ejecutándose:

         module.exports = {
           networks: {
             development: {
               host: 127.0.0.1,     // Localhost (default: none)
               port: 7545,            // Standard Ganache port (default: none)
               network_id: ,       // Any network (default: none)
             },
           },
           // Configure your compilers
           compilers: {
             solc: {
               version: 0.8.0,      // Fetch exact version from solc-bin (default: truffles version)
             }
           }
         }
       

Primer Contrato Inteligente

A continuación, creamos un simple contrato inteligente para verificar que todo está configurado correctamente:

1. En la carpeta contracts/, crear un archivo llamado SimpleStorage.sol con el siguiente contenido:

         // SPDX-License-Identifier: MIT
         pragma solidity ^0.8.0
   
         contract SimpleStorage {
             uint256 storedData
   
             function set(uint256 x) public {
                 storedData = x
             }
   
             function get() public view returns (uint256) {
                 return storedData
             }
         }
       

2. Crear una migración para desplegar el contrato en la carpeta migrations/:

         const SimpleStorage = artifacts.require(SimpleStorage)
   
         module.exports = function (deployer) {
           deployer.deploy(SimpleStorage)
         }
       

3. Desplegar el contrato en Ganache:

         truffle migrate
       

Si todo está correctamente configurado, el contrato debería desplegarse sin errores.

Conclusión

Hemos configurado exitosamente nuestro entorno de desarrollo para Solidity utilizando VSCode, Node.js, Truffle y Ganache. A partir de aquí, podemos comenzar a escribir, probar y desplegar contratos inteligentes en una red de desarrollo local. Este entorno es fundamental para el desarrollo profesional de contratos inteligentes en Ethereum.

Anterior…Siguiente

[mwai_chat]