Cómo desarrollar y probar una dapp en una red de prueba local multicliente
Introducción
Esta guía le muestra el proceso de instanciar una red de prueba local y configurable de Ethereum, desplegar un contrato inteligente en ella y usar la red de prueba para ejecutar pruebas en su aplicación descentralizada (dapp). Esta guía está diseñada para desarrolladores de dapps que desean desarrollar y probar sus dapps localmente en diferentes configuraciones de red antes de desplegarlas en una red de prueba en vivo o en la Red principal.
En esta guía, usted:
- Instanciará una red de prueba local de Ethereum con el
eth-network-package(opens in a new tab) usando Kurtosis (opens in a new tab), - Conectará su entorno de desarrollo de dapps Hardhat a la red de prueba local para compilar, desplegar y probar una dapp, y
- Configurará la red de prueba local, incluyendo parámetros como el número de nodos y emparejamientos específicos de clientes de la capa de ejecución (EL) y la capa de consenso (CL), para habilitar flujos de trabajo de desarrollo y pruebas en varias configuraciones de red.
¿Qué es Kurtosis?
Kurtosis (opens in a new tab) es un sistema de construcción componible diseñado para configurar entornos de prueba multicontenedor. Específicamente, permite a los desarrolladores crear entornos reproducibles que requieren una lógica de configuración dinámica, como las redes de prueba de cadenas de bloques.
En esta guía, el paquete eth-network-package de Kurtosis pone en marcha una red de prueba local de Ethereum con soporte para el cliente de la capa de ejecución (EL) geth (opens in a new tab), así como para los clientes de la capa de consenso (CL) teku (opens in a new tab), lighthouse (opens in a new tab) y lodestar (opens in a new tab). Este paquete sirve como una alternativa configurable y componible a las redes en marcos de trabajo como Hardhat Network, Ganache y Anvil. Kurtosis ofrece a los desarrolladores un mayor control y flexibilidad sobre las redes de prueba que utilizan, lo cual es una de las principales razones por las que la Fundación Ethereum usó Kurtosis para probar La Fusión (opens in a new tab) y continúa usándolo para probar las actualizaciones de la red.
Configuración de Kurtosis
Antes de continuar, asegúrese de tener:
- Instalado e iniciado el motor de Docker (opens in a new tab) en su máquina local
- Instalada la CLI de Kurtosis (opens in a new tab) (o actualizada a la última versión, si ya tiene la CLI instalada)
- Instalados Node.js (opens in a new tab), yarn (opens in a new tab) y npx (opens in a new tab) (para su entorno de dapp)
Instanciación de una red de prueba local de Ethereum
Para poner en marcha una red de prueba local de Ethereum, ejecute:
kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
Nota: Este comando nombra a su red: "local-eth-testnet" usando la bandera --enclave.
Kurtosis imprimirá los pasos que está tomando internamente mientras trabaja para interpretar, validar y luego ejecutar las instrucciones. Al final, debería ver una salida que se asemeje a la siguiente:
INFO[2023-04-04T18:09:44-04:00] ======================================================
INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
INFO[2023-04-04T18:09:44-04:00] ======================================================
Name: local-eth-testnet
UUID: 39372d756ae8
Status: RUNNING
Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
========================================= Files Artifacts =========================================
UUID Name
d4085a064230 cl-genesis-data
1c62cb792e4c el-genesis-data
bd60489b73a7 genesis-generation-config-cl
b2e593fe5228 genesis-generation-config-el
d552a54acf78 geth-prefunded-keys
5f7e661eb838 prysm-password
054e7338bb59 validator-keystore-0
========================================== User Services ==========================================
UUID Name Ports Status
e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> <http://127.0.0.1:54261> RUNNING
metrics: 5054/tcp -> <http://127.0.0.1:54262>
tcp-discovery: 9000/tcp -> 127.0.0.1:54263
udp-discovery: 9000/udp -> 127.0.0.1:60470
a8b6c926cdb4 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:54267 RUNNING
metrics: 5064/tcp -> <http://127.0.0.1:54268>
d7b802f623e8 el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:54253 RUNNING
rpc: 8545/tcp -> 127.0.0.1:54251
tcp-discovery: 30303/tcp -> 127.0.0.1:54254
udp-discovery: 30303/udp -> 127.0.0.1:53834
ws: 8546/tcp -> 127.0.0.1:54252
514a829c0a84 prelaunch-data-generator-1680646157905431468 <none> STOPPED
62bd62d0aa7a prelaunch-data-generator-1680646157915424301 <none> STOPPED
05e9619e0e90 prelaunch-data-generator-1680646157922872635 <none> STOPPED
¡Felicidades! Usó Kurtosis para instanciar una red de prueba local de Ethereum, con un cliente de la capa de consenso (lighthouse) y un cliente de la capa de ejecución (geth), sobre Docker.
Repaso
En esta sección, ejecutó un comando que indicó a Kurtosis que usara el eth-network-package alojado de forma remota en GitHub (opens in a new tab) para poner en marcha una red de prueba local de Ethereum dentro de un Enclave (opens in a new tab) de Kurtosis. Dentro de su enclave, encontrará tanto "artefactos de archivo" como "servicios de usuario".
Los Artefactos de archivo (opens in a new tab) en su enclave incluyen todos los datos generados y utilizados para arrancar los clientes de la capa de ejecución y la capa de consenso. Los datos se crearon usando el servicio prelaunch-data-generator construido a partir de esta imagen de Docker (opens in a new tab)
Los servicios de usuario muestran todos los servicios en contenedores que operan en su enclave. Notará que se ha creado un solo nodo, que cuenta tanto con un cliente de la capa de ejecución como con un cliente de la capa de consenso.
Conecte su entorno de desarrollo de dapps a la red de prueba local de Ethereum
Configuración del entorno de desarrollo de dapps
Ahora que tiene una red de prueba local en ejecución, puede conectar su entorno de desarrollo de dapps para usar su red de prueba local. En esta guía se utilizará el entorno Hardhat para desplegar una dapp de blackjack en su red de prueba local.
Para configurar su entorno de desarrollo de dapps, clone el repositorio que contiene nuestra dapp de muestra e instale sus dependencias, ejecute:
git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn
La carpeta smart-contract-example (opens in a new tab) utilizada aquí contiene la configuración típica para un desarrollador de dapps que usa el entorno Hardhat (opens in a new tab):
contracts/(opens in a new tab) contiene algunos contratos inteligentes simples para una dapp de Blackjackscripts/(opens in a new tab) contiene un script para desplegar un contrato de token en su red local de Ethereumtest/(opens in a new tab) contiene una prueba simple en .js para su contrato de token para confirmar que a cada jugador en nuestra dapp de Blackjack se le han acuñado 1000hardhat.config.ts(opens in a new tab) configura su instalación de Hardhat
Configuración de Hardhat para usar la red de prueba local
Con su entorno de desarrollo de dapps configurado, ahora conectará Hardhat para usar la red de prueba local de Ethereum generada mediante Kurtosis. Para lograr esto, reemplace <$YOUR_PORT> en la estructura localnet en su archivo de configuración hardhat.config.ts con el puerto de la salida de la URI de RPC de cualquier servicio el-client-<num>. En este caso de muestra, el puerto sería 64248. Su puerto será diferente.
Ejemplo en hardhat.config.ts:
localnet: {
url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO: REEMPLAZA $YOUR_PORT CON EL PUERTO DE UN URI DE NODO PRODUCIDO POR EL PAQUETE KURTOSIS DE LA RED ETH
// Estas son claves privadas asociadas con cuentas de prueba prefinanciadas creadas por el eth-network-package
// <https://github.com/kurtosis-tech/eth-network-package/blob/main/src/prelaunch_data_generator/genesis_constants/genesis_constants.star>
accounts: [
"ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
"48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
"7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
"b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
"df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
"7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
],
},
Una vez que guarde su archivo, ¡su entorno de desarrollo de dapps Hardhat estará conectado a su red de prueba local de Ethereum! Puede verificar que su red de prueba está funcionando ejecutando:
npx hardhat balances --network localnet
La salida debería verse algo así:
0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000
Esto confirma que Hardhat está usando su red de prueba local y detecta las cuentas prefinanciadas creadas por el eth-network-package.
Despliegue y prueba de su dapp localmente
Con el entorno de desarrollo de dapps completamente conectado a la red de prueba local de Ethereum, ahora puede ejecutar flujos de trabajo de desarrollo y pruebas en su dapp usando la red de prueba local.
Para compilar y desplegar el contrato inteligente ChipToken.sol para la creación de prototipos y el desarrollo local, ejecute:
npx hardhat compile
npx hardhat run scripts/deploy.ts --network localnet
La salida debería verse algo así:
ChipToken deployed to: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d
Ahora intente ejecutar la prueba simple.js en su dapp local para confirmar que a cada jugador en nuestra dapp de Blackjack se le han acuñado 1000:
La salida debería verse algo así:
npx hardhat test --network localnet
La salida debería verse algo así:
ChipToken
mint
✔ should mint 1000 chips for PLAYER ONE
1 passing (654ms)
Repaso
En este punto, ya ha configurado un entorno de desarrollo de dapps, lo ha conectado a una red local de Ethereum creada por Kurtosis, y ha compilado, desplegado y ejecutado una prueba simple en su dapp.
Ahora exploremos cómo puede configurar la red subyacente para probar nuestras dapps bajo diferentes configuraciones de red.
Configuración de la red de prueba local de Ethereum
Cambio de las configuraciones de los clientes y el número de nodos
Su red de prueba local de Ethereum se puede configurar para usar diferentes pares de clientes de la capa de ejecución y la capa de consenso, así como un número variable de nodos, dependiendo del escenario y la configuración de red específica que desee desarrollar o probar. Esto significa que, una vez configurada, puede poner en marcha una red de prueba local personalizada y usarla para ejecutar los mismos flujos de trabajo (despliegue, pruebas, etc.) bajo varias configuraciones de red para asegurarse de que todo funcione como se espera. Para obtener más información sobre los otros parámetros que puede modificar, visite este enlace.
¡Pruébelo! Puede pasar varias opciones de configuración al eth-network-package a través de un archivo JSON. Este archivo JSON de parámetros de red proporciona las configuraciones específicas que Kurtosis usará para configurar la red local de Ethereum.
Tome el archivo de configuración predeterminado y edítelo para poner en marcha dos nodos con diferentes pares de clientes de la capa de ejecución y la capa de consenso:
- Nodo 1 con
geth/lighthouse - Nodo 2 con
geth/lodestar - Nodo 3 con
geth/teku
Esta configuración crea una red heterogénea de implementaciones de nodos de Ethereum para probar su dapp. Su archivo de configuración ahora debería verse así:
{
"participants":
[
{
"el_client_type": "geth",
"el_client_image": "",
"el_client_log_level": "",
"cl_client_type": "lighthouse",
"cl_client_image": "",
"cl_client_log_level": "",
"beacon_extra_params": [],
"el_extra_params": [],
"validator_extra_params": [],
"builder_network_params": null,
},
{
"el_client_type": "geth",
"el_client_image": "",
"el_client_log_level": "",
"cl_client_type": "lodestar",
"cl_client_image": "",
"cl_client_log_level": "",
"beacon_extra_params": [],
"el_extra_params": [],
"validator_extra_params": [],
"builder_network_params": null,
},
{
"el_client_type": "geth",
"el_client_image": "",
"el_client_log_level": "",
"cl_client_type": "teku",
"cl_client_image": "",
"cl_client_log_level": "",
"beacon_extra_params": [],
"el_extra_params": [],
"validator_extra_params": [],
"builder_network_params": null,
},
],
"network_params":
{
"preregistered_validator_keys_mnemonic": "giant issue aisle success illegal bike spike question tent bar rely arctic volcano long crawl hungry vocal artwork sniff fantasy very lucky have athlete",
"num_validator_keys_per_node": 64,
"network_id": "3151908",
"deposit_contract_address": "0x4242424242424242424242424242424242424242",
"seconds_per_slot": 12,
"genesis_delay": 120,
"capella_fork_epoch": 5,
},
}
Cada estructura participants se asigna a un nodo en la red, por lo que 3 estructuras participants le dirán a Kurtosis que ponga en marcha 3 nodos en su red. Cada estructura participants le permitirá especificar el par de clientes de la capa de ejecución y la capa de consenso utilizado para ese nodo específico.
La estructura network_params configura los ajustes de red que se utilizan para crear los archivos génesis para cada nodo, así como otros ajustes como los segundos por slot de la red.
Guarde su archivo de parámetros editado en cualquier directorio que desee (en el ejemplo a continuación, se guarda en el escritorio) y luego úselo para ejecutar su paquete de Kurtosis ejecutando:
kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"
Nota: el comando kurtosis clean -a se usa aquí para indicar a Kurtosis que destruya la antigua red de prueba y su contenido antes de iniciar una nueva.
Nuevamente, Kurtosis trabajará un poco e imprimirá los pasos individuales que se están llevando a cabo. Eventualmente, la salida debería verse algo así:
Starlark code successfully run. No output was returned.
INFO[2023-04-07T11:43:16-04:00] ==========================================================
INFO[2023-04-07T11:43:16-04:00] || Created enclave: local-eth-testnet ||
INFO[2023-04-07T11:43:16-04:00] ==========================================================
Name: local-eth-testnet
UUID: bef8c192008e
Status: RUNNING
Creation Time: Fri, 07 Apr 2023 11:41:58 EDT
========================================= Files Artifacts =========================================
UUID Name
cc495a8e364a cl-genesis-data
7033fcdb5471 el-genesis-data
a3aef43fc738 genesis-generation-config-cl
8e968005fc9d genesis-generation-config-el
3182cca9d3cd geth-prefunded-keys
8421166e234f prysm-password
d9e6e8d44d99 validator-keystore-0
23f5ba517394 validator-keystore-1
4d28dea40b5c validator-keystore-2
========================================== User Services ==========================================
UUID Name Ports Status
485e6fde55ae cl-client-0-beacon http: 4000/tcp -> http://127.0.0.1:65010 RUNNING
metrics: 5054/tcp -> http://127.0.0.1:65011
tcp-discovery: 9000/tcp -> 127.0.0.1:65012
udp-discovery: 9000/udp -> 127.0.0.1:54455
73739bd158b2 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:65016 RUNNING
metrics: 5064/tcp -> http://127.0.0.1:65017
1b0a233cd011 cl-client-1-beacon http: 4000/tcp -> 127.0.0.1:65021 RUNNING
metrics: 8008/tcp -> 127.0.0.1:65023
tcp-discovery: 9000/tcp -> 127.0.0.1:65024
udp-discovery: 9000/udp -> 127.0.0.1:56031
validator-metrics: 5064/tcp -> 127.0.0.1:65022
949b8220cd53 cl-client-1-validator http: 4000/tcp -> 127.0.0.1:65028 RUNNING
metrics: 8008/tcp -> 127.0.0.1:65030
tcp-discovery: 9000/tcp -> 127.0.0.1:65031
udp-discovery: 9000/udp -> 127.0.0.1:60784
validator-metrics: 5064/tcp -> 127.0.0.1:65029
c34417bea5fa cl-client-2 http: 4000/tcp -> 127.0.0.1:65037 RUNNING
metrics: 8008/tcp -> 127.0.0.1:65035
tcp-discovery: 9000/tcp -> 127.0.0.1:65036
udp-discovery: 9000/udp -> 127.0.0.1:63581
e19738e6329d el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:64986 RUNNING
rpc: 8545/tcp -> 127.0.0.1:64988
tcp-discovery: 30303/tcp -> 127.0.0.1:64987
udp-discovery: 30303/udp -> 127.0.0.1:55706
ws: 8546/tcp -> 127.0.0.1:64989
e904687449d9 el-client-1 engine-rpc: 8551/tcp -> 127.0.0.1:64993 RUNNING
rpc: 8545/tcp -> 127.0.0.1:64995
tcp-discovery: 30303/tcp -> 127.0.0.1:64994
udp-discovery: 30303/udp -> 127.0.0.1:58096
ws: 8546/tcp -> 127.0.0.1:64996
ad6f401126fa el-client-2 engine-rpc: 8551/tcp -> 127.0.0.1:65003 RUNNING
rpc: 8545/tcp -> 127.0.0.1:65001
tcp-discovery: 30303/tcp -> 127.0.0.1:65000
udp-discovery: 30303/udp -> 127.0.0.1:57269
ws: 8546/tcp -> 127.0.0.1:65002
12d04a9dbb69 prelaunch-data-generator-1680882122181135513 <none> STOPPED
5b45f9c0504b prelaunch-data-generator-1680882122192182847 <none> STOPPED
3d4aaa75e218 prelaunch-data-generator-1680882122201668972 <none> STOPPED
¡Felicidades! Ha configurado con éxito su red de prueba local para tener 3 nodos en lugar de 1. Para ejecutar los mismos flujos de trabajo que hizo antes en su dapp (desplegar y probar), realice las mismas operaciones que hicimos antes reemplazando el <$YOUR_PORT> en la estructura localnet en su archivo de configuración hardhat.config.ts con el puerto de la salida de la URI de RPC de cualquier servicio el-client-<num> en su nueva red de prueba local de 3 nodos.
Conclusión
¡Y eso es todo! Para resumir esta breve guía, usted:
- Creó una red de prueba local de Ethereum sobre Docker usando Kurtosis
- Conectó su entorno de desarrollo de dapps local a la red local de Ethereum
- Desplegó una dapp y ejecutó una prueba simple en ella en la red local de Ethereum
- Configuró la red de Ethereum subyacente para tener 3 nodos
Nos encantaría saber de usted sobre qué le funcionó bien, qué se podría mejorar o responder a cualquiera de sus preguntas. ¡No dude en comunicarse a través de GitHub (opens in a new tab) o enviarnos un correo electrónico (opens email client)!
Otros ejemplos y guías
Le animamos a que consulte nuestro inicio rápido (opens in a new tab) (donde construirá una base de datos Postgres y una API encima) y nuestros otros ejemplos en nuestro repositorio awesome-kurtosis (opens in a new tab) donde encontrará algunos ejemplos excelentes, incluyendo paquetes para:
- Poner en marcha la misma red de prueba local de Ethereum (opens in a new tab), pero con servicios adicionales conectados como un generador de spam de transacciones (para simular transacciones), un monitor de bifurcaciones y una instancia conectada de Grafana y Prometheus
- Realizar una prueba de subredes (opens in a new tab) en la misma red local de Ethereum