Ir al contenido principal

Cómo desarrollar y probar una dApp en una red de prueba local multicliente

clientes
nodos
contratos Inteligentes
composabilidad
capa de consenso
capa de ejecución
pruebas
Intermedio
Tedi Mitiku
11 de abril de 2023
12 minuto leído

Introducción

Esta guía le guía a través del proceso de instanciación de una red de prueba local configurable de Ethereum, desplegando un contrato inteligente en ella y usando la red de prueba para ejecutar pruebas en su dApp. Esta guía está diseñada para desarrolladores de dApps que desean desarrollar y probar sus dApps localmente con diferentes configuraciones de red antes de desplegarlas en una red de prueba activa o en la red principal.

En esta guía, usted:

  • Instanciar una red de prueba local de Ethereum con el eth-network-packageopens in a new tab usando Kurtosisopens 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 EL/CL, para permitir flujos de trabajo de desarrollo y prueba con varias configuraciones de red.

¿Qué es Kurtosis?

Kurtosisopens in a new tab es un sistema de compilación componible diseñado para configurar entornos de prueba de múltiples contenedores. Permite específicamente a los desarrolladores crear entornos reproducibles que requieren una lógica de configuración dinámica, como las redes de prueba de la cadena 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) gethopens in a new tab, así como para los clientes de la capa de consenso (CL) tekuopens in a new tab, lighthouseopens in a new tab y lodestaropens in a new tab. Este paquete sirve como una alternativa configurable y componible a las redes en marcos como Hardhat Network, Ganache y Anvil. Kurtosis ofrece a los desarrolladores un mayor control y flexibilidad sobre las redes de prueba que utilizan, que es una razón importante por la que la Ethereum Foundation utilizó Kurtosis para probar la Fusiónopens 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 que tiene:

Instanciar una red de prueba local de Ethereum

Para poner en marcha una red de prueba local de Ethereum, ejecute:

1kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package

Nota: Este comando nombra su red como: "local-eth-testnet" usando la bandera --enclave.

Kurtosis imprimirá los pasos que está realizando internamente mientras trabaja para interpretar, validar y luego ejecutar las instrucciones. Al final, debería ver una salida que se parezca a la siguiente:

1INFO[2023-04-04T18:09:44-04:00] ======================================================
2INFO[2023-04-04T18:09:44-04:00] ||          Created enclave: local-eth-testnet      ||
3INFO[2023-04-04T18:09:44-04:00] ======================================================
4Name:            local-eth-testnet
5UUID:            39372d756ae8
6Status:          RUNNING
7Creation Time:   Tue, 04 Apr 2023 18:09:03 EDT
8
9========================================= Files Artifacts =========================================
10UUID           Name
11d4085a064230   cl-genesis-data
121c62cb792e4c   el-genesis-data
13bd60489b73a7   genesis-generation-config-cl
14b2e593fe5228   genesis-generation-config-el
15d552a54acf78   geth-prefunded-keys
165f7e661eb838   prysm-password
17054e7338bb59   validator-keystore-0
18
19========================================== User Services ==========================================
20UUID           Name                                           Ports                                         Status
21e20f129ee0c5   cl-client-0-beacon                             http: 4000/tcp -> <http://127.0.0.1:54261>    RUNNING
22                                                              metrics: 5054/tcp -> <http://127.0.0.1:54262>
23                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:54263
24                                                              udp-discovery: 9000/udp -> 127.0.0.1:60470
25a8b6c926cdb4   cl-client-0-validator                          http: 5042/tcp -> 127.0.0.1:54267             RUNNING
26                                                              metrics: 5064/tcp -> <http://127.0.0.1:54268>
27d7b802f623e8   el-client-0                                    engine-rpc: 8551/tcp -> 127.0.0.1:54253       RUNNING
28                                                              rpc: 8545/tcp -> 127.0.0.1:54251
29                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:54254
30                                                              udp-discovery: 30303/udp -> 127.0.0.1:53834
31                                                              ws: 8546/tcp -> 127.0.0.1:54252
32514a829c0a84   prelaunch-data-generator-1680646157905431468   <none>                                        STOPPED
3362bd62d0aa7a   prelaunch-data-generator-1680646157915424301   <none>                                        STOPPED
3405e9619e0e90   prelaunch-data-generator-1680646157922872635   <none>                                        STOPPED
35
Mostrar todo

¡Felicitaciones! Ha utilizado Kurtosis para instanciar una red de prueba local de Ethereum, con un cliente de CL (lighthouse) y un cliente de EL (geth), sobre Docker.

Revisión

En esta sección, ejecutó un comando que ordenó a Kurtosis que utilizara el eth-network-package alojado de forma remota en GitHubopens in a new tab para poner en marcha una red de prueba local de Ethereum dentro de un Enclaveopens in a new tab de Kurtosis. Dentro de su enclave, encontrará tanto "artefactos de archivo" como "servicios de usuario".

Los Artefactos de archivoopens in a new tab en su enclave incluyen todos los datos generados y utilizados para arrancar los clientes EL y CL. Los datos se crearon utilizando el servicio prelaunch-data-generator creado a partir de esta imagen de Dockeropens 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 único nodo, que cuenta con un cliente de EL y un cliente de CL.

Conecte su entorno de desarrollo de dApp a la red de prueba local de Ethereum

Configurar el entorno de desarrollo de dApp

Ahora que tiene una red de prueba local en funcionamiento, puede conectar su entorno de desarrollo de dApp para usar su red de prueba local. El marco Hardhat se utilizará en esta guía para desplegar una dApp de blackjack en su red de prueba local.

Para configurar su entorno de desarrollo de dApp, clone el repositorio que contiene nuestra dApp de muestra e instale sus dependencias, ejecute:

1git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn

La carpeta smart-contract-exampleopens in a new tab utilizada aquí contiene la configuración típica para un desarrollador de dApp que utiliza el marco Hardhatopens in a new tab:

Configurar Hardhat para usar la red de prueba local

Con su entorno de desarrollo de dApp configurado, ahora conectará Hardhat para usar la red de prueba local de Ethereum generada usando 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 del URI 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:

1localnet: {
2url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO: REEMPLACE $YOUR_PORT CON EL PUERTO DE UN URI DE NODO PRODUCIDO POR EL PAQUETE DE RED ETH DE KURTOSIS
3
4// Estas son claves privadas asociadas con cuentas de prueba prefinanciadas creadas por el paquete de red eth
5// <https://github.com/kurtosis-tech/eth-network-package/blob/main/src/prelaunch_data_generator/genesis_constants/genesis_constants.star>
6accounts: [
7    "ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
8    "48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
9    "7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
10    "b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
11    "df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
12    "7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
13  ],
14},
Mostrar todo

Una vez que guarde el 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 funciona ejecutando:

1npx hardhat balances --network localnet

La salida debería parecerse a esto:

10x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
20x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
30xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
40x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
50x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
60x1F6298457C5d76270325B724Da5d1953923a6B88 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 pruebe su dApp localmente

Con el entorno de desarrollo de dApp totalmente conectado a la red de prueba local de Ethereum, ahora puede ejecutar flujos de trabajo de desarrollo y prueba en su dApp utilizando la red de prueba local.

Para compilar y desplegar el contrato inteligente ChipToken.sol para prototipos y desarrollo local, ejecute:

1npx hardhat compile
2npx hardhat run scripts/deploy.ts --network localnet

La salida debería ser algo como:

1ChipToken desplegado en: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d

Ahora intente ejecutar la prueba simple.js en su dApp local para confirmar que a cada jugador de nuestra dApp de Blackjack se le hayan acuñado 1000:

La salida debería parecerse a esto:

1npx hardhat test --network localnet

La salida debería parecerse a esto:

1ChipToken
2    mint
3      ✔ debería acuñar 1000 fichas para PLAYER ONE
4
5  1 aprobada (654ms)

Revisión

En este punto, ya ha configurado un entorno de desarrollo de dApp, 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 diversas configuraciones de red.

Configuración de la red de prueba local de Ethereum

Cambio de las configuraciones del cliente y el número de nodos

Su red de prueba local de Ethereum puede configurarse para usar diferentes pares de clientes EL y CL, 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 utilizarla para ejecutar los mismos flujos de trabajo (despliegue, pruebas, etc.) bajo varias configuraciones de red para garantizar 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 utilizará 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 EL/CL:

  • 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 debería tener este aspecto:

1{
2  "participants":
3    [
4      {
5        "el_client_type": "geth",
6        "el_client_image": "",
7        "el_client_log_level": "",
8        "cl_client_type": "lighthouse",
9        "cl_client_image": "",
10        "cl_client_log_level": "",
11        "beacon_extra_params": [],
12        "el_extra_params": [],
13        "validator_extra_params": [],
14        "builder_network_params": null,
15      },
16      {
17        "el_client_type": "geth",
18        "el_client_image": "",
19        "el_client_log_level": "",
20        "cl_client_type": "lodestar",
21        "cl_client_image": "",
22        "cl_client_log_level": "",
23        "beacon_extra_params": [],
24        "el_extra_params": [],
25        "validator_extra_params": [],
26        "builder_network_params": null,
27      },
28      {
29        "el_client_type": "geth",
30        "el_client_image": "",
31        "el_client_log_level": "",
32        "cl_client_type": "teku",
33        "cl_client_image": "",
34        "cl_client_log_level": "",
35        "beacon_extra_params": [],
36        "el_extra_params": [],
37        "validator_extra_params": [],
38        "builder_network_params": null,
39      },
40    ],
41  "network_params":
42    {
43      "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",
44      "num_validator_keys_per_node": 64,
45      "network_id": "3151908",
46      "deposit_contract_address": "0x4242424242424242424242424242424242424242",
47      "seconds_per_slot": 12,
48      "genesis_delay": 120,
49      "capella_fork_epoch": 5,
50    },
51}
Mostrar todo

Cada estructura de participants se corresponde con un nodo de la red, por lo que 3 estructuras de participants le indicarán a Kurtosis que ponga en marcha 3 nodos en su red. Cada estructura de participants le permitirá especificar el par EL y CL utilizado para ese nodo específico.

La estructura network_params configura los ajustes de red que se utilizan para crear los archivos de génesis para cada nodo, así como otros ajustes como los segundos por ranura de la red.

Guarde el archivo de parámetros editado en el directorio que desee (en el siguiente ejemplo, se guarda en el escritorio) y, a continuación, utilícelo para ejecutar su paquete Kurtosis ejecutando:

1kurtosis 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 utiliza aquí para indicar a Kurtosis que destruya la antigua red de prueba y su contenido antes de iniciar una nueva.

De nuevo, Kurtosis funcionará durante un rato e imprimirá los pasos individuales que se están llevando a cabo. Finalmente, la salida debería ser algo como:

1Código Starlark ejecutado con éxito. No se devolvió ninguna salida.
2INFO[2023-04-07T11:43:16-04:00] ==========================================================
3INFO[2023-04-07T11:43:16-04:00] ||          Created enclave: local-eth-testnet          ||
4INFO[2023-04-07T11:43:16-04:00] ==========================================================
5Name:            local-eth-testnet
6UUID:            bef8c192008e
7Status:          RUNNING
8Creation Time:   Fri, 07 Apr 2023 11:41:58 EDT
9
10========================================= Files Artifacts =========================================
11UUID           Name
12cc495a8e364a   cl-genesis-data
137033fcdb5471   el-genesis-data
14a3aef43fc738   genesis-generation-config-cl
158e968005fc9d   genesis-generation-config-el
163182cca9d3cd   geth-prefunded-keys
178421166e234f   prysm-password
18d9e6e8d44d99   validator-keystore-0
1923f5ba517394   validator-keystore-1
204d28dea40b5c   validator-keystore-2
21
22========================================== User Services ==========================================
23UUID           Name                                           Ports                                            Status
24485e6fde55ae   cl-client-0-beacon                             http: 4000/tcp -> http://127.0.0.1:65010         RUNNING
25                                                              metrics: 5054/tcp -> http://127.0.0.1:65011
26                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65012
27                                                              udp-discovery: 9000/udp -> 127.0.0.1:54455
2873739bd158b2   cl-client-0-validator                          http: 5042/tcp -> 127.0.0.1:65016                RUNNING
29                                                              metrics: 5064/tcp -> http://127.0.0.1:65017
301b0a233cd011   cl-client-1-beacon                             http: 4000/tcp -> 127.0.0.1:65021                RUNNING
31                                                              metrics: 8008/tcp -> 127.0.0.1:65023
32                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65024
33                                                              udp-discovery: 9000/udp -> 127.0.0.1:56031
34                                                              validator-metrics: 5064/tcp -> 127.0.0.1:65022
35949b8220cd53   cl-client-1-validator                          http: 4000/tcp -> 127.0.0.1:65028                RUNNING
36                                                              metrics: 8008/tcp -> 127.0.0.1:65030
37                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65031
38                                                              udp-discovery: 9000/udp -> 127.0.0.1:60784
39                                                              validator-metrics: 5064/tcp -> 127.0.0.1:65029
40c34417bea5fa   cl-client-2                                    http: 4000/tcp -> 127.0.0.1:65037                RUNNING
41                                                              metrics: 8008/tcp -> 127.0.0.1:65035
42                                                              tcp-discovery: 9000/tcp -> 127.0.0.1:65036
43                                                              udp-discovery: 9000/udp -> 127.0.0.1:63581
44e19738e6329d   el-client-0                                    engine-rpc: 8551/tcp -> 127.0.0.1:64986          RUNNING
45                                                              rpc: 8545/tcp -> 127.0.0.1:64988
46                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:64987
47                                                              udp-discovery: 30303/udp -> 127.0.0.1:55706
48                                                              ws: 8546/tcp -> 127.0.0.1:64989
49e904687449d9   el-client-1                                    engine-rpc: 8551/tcp -> 127.0.0.1:64993          RUNNING
50                                                              rpc: 8545/tcp -> 127.0.0.1:64995
51                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:64994
52                                                              udp-discovery: 30303/udp -> 127.0.0.1:58096
53                                                              ws: 8546/tcp -> 127.0.0.1:64996
54ad6f401126fa   el-client-2                                    engine-rpc: 8551/tcp -> 127.0.0.1:65003          RUNNING
55                                                              rpc: 8545/tcp -> 127.0.0.1:65001
56                                                              tcp-discovery: 30303/tcp -> 127.0.0.1:65000
57                                                              udp-discovery: 30303/udp -> 127.0.0.1:57269
58                                                              ws: 8546/tcp -> 127.0.0.1:65002
5912d04a9dbb69   prelaunch-data-generator-1680882122181135513   <none>                                           STOPPED
605b45f9c0504b   prelaunch-data-generator-1680882122192182847   <none>                                           STOPPED
613d4aaa75e218   prelaunch-data-generator-1680882122201668972   <none>                                           STOPPED
Mostrar todo

¡Felicitaciones! Ha configurado correctamente su red de prueba local para que tenga 3 nodos en lugar de 1. Para ejecutar los mismos flujos de trabajo que antes en su dApp (despliegue y prueba), realice las mismas operaciones que hicimos antes reemplazando <$YOUR_PORT> en la estructura localnet en su archivo de configuración hardhat.config.ts con el puerto de la salida del URI rpc de cualquier servicio el-client-<num> en su nueva red de prueba local de 3 nodos.

Conclusión

¡Y eso es todo! Para recapitular esta breve guía, usted:

  • Creó una red de prueba local de Ethereum sobre Docker usando Kurtosis
  • Conectó su entorno de desarrollo de dApp 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 subyacente de Ethereum para tener 3 nodos

Nos encantaría saber qué le ha parecido, qué se podría mejorar o responder a cualquiera de sus preguntas. No dude en ponerse en contacto con nosotros a través de GitHubopens in a new tab o envíenos un correo electrónicoopens email client.

Otros ejemplos y guías

Le animamos a que consulte nuestro inicio rápidoopens in a new tab (donde creará una base de datos Postgres y una API sobre ella) y nuestros otros ejemplos en nuestro repositorio awesome-kurtosisopens in a new tab donde encontrará algunos ejemplos geniales, incluyendo paquetes para:

  • Poner en marcha la misma red de prueba local de Ethereum, 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 subredesopens in a new tab en la misma red local de Ethereum

Última actualización de la página: 23 de septiembre de 2025

mdqstmopens in a new tab
brossetti1bopens in a new tab
pettinarippopens in a new tab
+2

¿Le ha resultado útil este tutorial?