Cómo implementar Sepolia: Red de prueba de Ethereum

Antes de implementar un contrato en una red de mainnet como Ethereum debemos primero saber cómo implementar Sepolia. Esto con el fin de poder simular un comportamiento más acertado en cuanto a la congestión y costos de transacciones en total. Así mismo como la modificación del algoritmo. Así que sin más, vamos a comenzar !

Lo que vas a necesitar

• Hoja de excel: haz click aquí para ver la hoja de de excel con los cálculos de costos para nuestras ejecuciones.
• Repositorio: haz click aquí para ver el repositorio en github. Recuerda ver los commits para posicionarte en la sesión que deseas ver.
• Etherscan sepolia: haz click aquí para ver la web.
• Faucet infura: haz click aquí para obtener faucet de infura.
• Faucet holesky: haz click aquí para obtener el faucet de holesky.

1. Cómo obtener faucet de Sepolia

El primer paso para poder implementar el contrato del curso usando Sepolia es obtener el faucet. Como Sepolia es una red de prueba de ethereum, como tal el saldo no es Ethereum si no SEPOLIA ETHEREUM. Entonces no debemos como tal comprarlo sino obtener saldo o faucet para poder realizar transacciones.

Este facuet se puede obtener en diferentes páginas web pero tal vez la más recomendada siempre será Infura. En este caso infura permite hacerlo de una forma sencilla, solo debemos copiar y pegar nuestra dirección obtenida en las primeras sesiones de metamask, y esperar a obtener el faucet. Pero par este paso INFURA COMO OTRAS PÁGINAS solicitan que se tenga un valor mínimo en ethereum real. Entonces deberás tener (para el caso de infura) un pequeño saldo de ethereum.

Una vez realizado el envío del faucet, podrás verlo en tu wallet. Solo debes cambiar la red de Ethereum a Sepolia, como en la imagen anterior, en la parte superior izquierda. Cabe resaltar que es la misma dirección, solo cambia la red.

2. Proveedor de conexión de blockchain

Este segundo paso se basa en crear una API dentro de Infura. A parte de proporcionar el faucet, Infura principalmente nos permite conectarnos a blockchain desde diferentes cripto y desde redes de mainnet y de prueba. Entonces este proveedor es prácticamente la mitad del trabajo. Claro que cobra por su trabajo pero podemos hacerlo de forma gratuita antes de ciertas solicitudes.

Lo que debes hacer es crear una cuenta en infura y luego crear una api. Esta como en la imagen anterior, debes habilitarla para SEPOLIA, HOLESKY Y MAINNET. Las 3 funcionarán con la configuración del siguiente paso, pero básicamente mainnet se refiere a la red principal de ethereum, o red de producción, mientras que sepolia y holesky son redes de prueba del mismo ETHEREUM.

A continuación, lo que debes hacer es ir a la sección active endpoints y podrás ver dos opciones: htttps y webSockets. Ambas opciones puedes usarlas sin problema en el siguiente paso, pero lo importante es que las tengas disponibles. Por último es imporante copiar y pegar estas URLS a nuestro archivo .env y al crear las variables de entorno, podemos proceder al siguiente paso.

3. Modificación de truffle config para añadir redes

Este tercer paso consiste en añadir las redes de prueba creadas en el paso anterior, a nuestro código, dentro del archivo truffle config. Como lo vimos en las sesiones anteriores, este archivo controla desde donde se implementan los contratos y así mismo actualiza lo que pase con los mismos. En este caso agregaremos el siguiente fragmento:

holesky: {
        provider: function() { return new HDWalletProvider(process.env.MNEMONIC, process.env.ANKRHOLESKI);  }, 
        gas: 2000000,
        gasPrice: 3000000000,
        network_id: 17000,
        networkCheckTimeout: 3600000, // eperará 3600000 milisegundos o 1 hora
        timeoutBlocks: 301, // espera x bloques antes de irse a timeout. 1 Hora.
        confirmations: 2,
        skipDryRun: true,  // true para omitir la prueba en seco, false para realizar la prueba en s
      },
      sepolia: {
        provider: function() { return new HDWalletProvider(process.env.MNEMONIC, process.env.ANKRSEPOLIA);  }, 
        gas: 2000000,
        gasPrice: 7000000000,
        network_id: 11155111,  
        networkCheckTimeout: 3600000, 
        timeoutBlocks: 301, 
        confirmations: 2,
        skipDryRun: true,  
      },
      mainnet: {
        provider: function() { return new HDWalletProvider(process.env.MNEMONIC, process.env.INFURAMAINNET);  }, 
        gas: 2000000,
        gasPrice: 7000000000,
        network_id: 1,  
        networkCheckTimeout: 3600000, 
        timeoutBlocks: 301, 
        confirmations: 2,
        skipDryRun: false,  
      }

Aquí vamos a revisar varios factores:

• Provider: esta propiedad se enfoca en la configuración del proveedor de blockchain donde el primer argumento es la clave mnemónica. Esta la da metamask al momento de crear y son 13 o 14 palabras separadas por espacios. El segundo argumento es la URL obtenida en el paso dos. Recordar que debemos pegar las variables de entorno, nunca directamente las URLS o websockets.
• gas: determina cuántas unidades de gas vamos a gastar en la implementación. Como en la sesión anterior, revisamos qué es y cómo se calculan, también en el excel se encuentran actualizados los valores sobre cuántas unidades de gas vamos a necesitar para implementar nuestro contrato de lotería, que es más o menos 1.6 millones, en este caso lo dejamos configurado en 2 millones.
• NetworkCheckTimeout: Esperará cierta cantidad de milisegundos para poder entrar en timeout.
• timeoutblocks: esperará la cantidad de bloques escrita para ir a timeout.
• SkiDryRun: si estás en mainnet, debes dejarlo siempre en false y demás en true si deseas. Lo que hace esta opción es realizar las verificaciones iniciales antes de comenzar a migrar.

Función GASPRICE

Este paso es imporante dado que necesitamos conocer el costo de cada unidad de gas pero este cambia para todas las redes tanto de prueba como no, entonces debemos enconrarlo y para luego ingresarlo en truffle config.

// ENCONTRAR GASPRICE DE REDES /////////////////////////////
const Web3 = require('web3');
const web3Mainnet = new Web3(process.env.INFURAMAINNET);
const web3Sepolia = new Web3(process.env.INFURASEPOLIA); 
const web3Holeski = new Web3(process.env.INFURAHOLESKY); 

async function getBaseFeePerGas() {
  try {
    const blockMainnet = await web3Mainnet.eth.getBlock('latest');
    const blockSepolia = await web3Sepolia.eth.getBlock('latest');
    const blockHolesky = await web3Holeski.eth.getBlock('latest');
    
    const baseFeePerGasMainnet = blockMainnet.baseFeePerGas;
    const baseFeePerGasSepolia = blockSepolia.baseFeePerGas;
    const baseFeePerGasHolesky = blockHolesky.baseFeePerGas;

    console.log("BaseFeePerGas Actual Mainnet: ", baseFeePerGasMainnet.toLocaleString(), ". Sepolia: ", baseFeePerGasSepolia.toLocaleString() , ". holesky: ", baseFeePerGasHolesky.toLocaleString(),".");
  } catch (error) {
    console.error('Error al obtener el baseFeePerGas:', error);
  }
}
getBaseFeePerGas(); // EJECUTAR FUNCIÓN
// ENCONTRAR GASPRICE DE REDES /////////////////////////////

Ejecutar migración

Por último el paso más importante es realizar la migración y para esto vamos a necesitar el comando:

truffle migrate --network sepolia

Este claramente solo funciona para sepolia, pero si deseas implementar en otra, basta con cambiar el nombre. Una vez finalizda la migración podrás revisarla en etherescan sepolia y, ver los contratos creados.

Recordemos que etherscan hace seguimiento de todo lo que pasa en la dirección otorgada entonces aquí podremos ver exactamente los mismos movimientos de la sesión del curso cuando lo hicimos con ganache. Una vez confirmado podrás pasar a ejecutar el contrato del curso, bastta con.

1. Conseguir 2 o 3 direcciones de metamask.
2. Añadir faucet a cada una de ellas
3. realizar la reación de la lotería para cada wallet
4. volver a la wallet que creo el contrato (de la cual sacaste la frase mnemónica) y ejecutar la lotería.

Video de ayuda

hice este video para ayudarte en el proceso. Si te gusta no olvides dar lioke y suscribirte!

Producto sugerido

Si eres como yo que pasa bastatne tiempo frente al compu, puede que la barra de luz te sirva bastante para cuidar tu vista en esas largas jornadas. También te dejo aquí el post para que veas la reseña completa.

Conclusión

En esta última sesión del curso, aprendemos a cómo desplegar un contrato inteligente en la red de prueba sepolia. De esta manera, entendemos mejor cómo funciona un contrato dentro de la blockchain real.