13.2 Despliegue en redes de prueba (Ropsten, Rinkeby, Goerli)

Despliegue en redes de prueba con Solidity

Despliegue en redes de prueba (Ropsten, Rinkeby, Goerli)

El despliegue de contratos inteligentes en redes de prueba es una etapa crucial en el desarrollo de aplicaciones descentralizadas (dApps) utilizando Ethereum y Solidity. Las redes de prueba permiten verificar que el contrato funcione correctamente antes del despliegue en la red principal, evitando así pérdidas significativas de valor y asegurando un comportamiento esperado. Este punto cubrirá detalles profundos sobre cómo desplegar contratos en tres redes de prueba populares: Ropsten, Rinkeby y Goerli.

Configuración del entorno

Antes de desplegar el contrato en cualquier red de prueba, se necesita preparar el entorno. Esto incluye tener instalado Node.js, npm (Node Package Manager), Truffle (o Hardhat) y MetaMask (o cualquier otra billetera compatible con Ethereum).

Para comenzar, asegúrate de tener los siguientes componentes:

Node.js y npm instalados.
Truffle o Hardhat:
- Para Truffle, instala usando:
- Para Hardhat, instala usando:
MetaMask para gestionar nuestras cuentas y claves privadas.

Configuración de Truffle

Para este ejemplo, usaremos Truffle. Crear un nuevo proyecto de Truffle:

mkdir MyTruffleProject 
cd MyTruffleProject 
truffle init

Dentro de tu proyecto Truffle, crea un archivo Migrations.sol en la carpeta contracts con el contenido siguiente:

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

contract Migrations {
    address public owner = msg.sender
    uint public last_completed_migration

    modifier restricted() {
        require(
            msg.sender == owner,
            This function is restricted to the contracts owner
        )
        _
    }

    function setCompleted(uint completed) public restricted {
        last_completed_migration = completed
    }
}

Configuración de la red en Truffle

Edita el archivo truffle-config.js para agregar la configuración de las redes de prueba:

const HDWalletProvider = require(@truffle/hdwallet-provider)
const mnemonic = YOUR_METAMASK_MNEMONIC

module.exports = {
    networks: {
        ropsten: {
            provider: () =>
              new HDWalletProvider(mnemonic, https://ropsten.infura.io/v3/YOUR_INFURA_PROJECT_ID),
            network_id: 3,       // Ropstens id
            gas: 5500000,        // Ropsten has a lower block limit than mainnet
            confirmations: 2,    // # of confs to wait between deployments. (default: 0)
            timeoutBlocks: 200,  // # of blocks before a deployment times out  (minimum/default: 50)
            skipDryRun: true     // Skip dry run before migrations (default: false for public nets)
        },
        rinkeby: {
            provider: () =>
              new HDWalletProvider(mnemonic, https://rinkeby.infura.io/v3/YOUR_INFURA_PROJECT_ID),
            network_id: 4,       // Rinkebys id
            gas: 5500000,        
            confirmations: 2,    
            timeoutBlocks: 200,  
            skipDryRun: true
        },
        goerli: {
            provider: () =>
              new HDWalletProvider(mnemonic, https://goerli.infura.io/v3/YOUR_INFURA_PROJECT_ID),
            network_id: 5,       // Goerlis id
            gas: 5500000,        
            confirmations: 2,    
            timeoutBlocks: 200,  
            skipDryRun: true
        }
    },
    compilers: {
        solc: {
            version: 0.8.0,    // Fetch exact version from solc-bin (default: truffles version)
        }
    }
}

Nota: Reemplaza YOUR_METAMASK_MNEMONIC con la frase mnemónica de tu billetera MetaMask y YOUR_INFURA_PROJECT_ID con tu ID de proyecto Infura (puedes registrarte aquí para obtener uno).

Desplegar el contrato

Ahora, vamos a crear un archivo de migración en la carpeta migrations, llamado 2_deploy_contracts.js:

const Migrations = artifacts.require(Migrations)

module.exports = function (deployer) {
  deployer.deploy(Migrations)
}

Finalmente, despliega el contrato en la red seleccionada. Por ejemplo, para Ropsten:

truffle migrate --network ropsten

Para Rinkeby:

truffle migrate --network rinkeby

Para Goerli:

truffle migrate --network goerli

Verificar el despliegue

Puedes verificar el despliegue usando Etherscan con la URL específica para cada red:

Ingresa la dirección del contrato desplegado y verifica las transacciones, el bytecode, y otros detalles.

Conclusión

Desplegar contratos en redes de prueba como Ropsten, Rinkeby y Goerli es esencial para comprobar el funcionamiento correcto antes de llevarlo a la red principal. Asegúrate siempre de seguir buenas prácticas de desarrollo, incluyendo el uso de redes de prueba y la verificación exhaustiva de contratos.

Anterior…Siguiente

SynZeN