Pular para o conteúdo principal

Como desenvolver e testar um dApp em uma rede de teste local multicliente

clientes
nós
smart contracts
componibilidade
camada de consenso
camada de execução
testando
Intermediário
Tedi Mitiku
11 de abril de 2023
12 minutos de leitura

Introdução

Este guia o orienta no processo de instanciar uma rede de teste local configurável do Ethereum, implantar um contrato inteligente nela e usar a rede de teste para executar testes em seu dApp. Este guia foi elaborado para desenvolvedores de dApps que queiram desenvolver e testar seus dApps localmente em diferentes configurações de rede antes de implantar em uma rede de teste ativa ou na rede principal.

Neste guia, você irá:

  • Instanciar uma rede de teste local do Ethereum com o eth-network-package (opens in a new tab) usando Kurtosis (opens in a new tab),
  • Conectar seu ambiente de desenvolvimento de dApp Hardhat à rede de teste local para compilar, implantar e testar um dApp, e
  • Configurar a rede de teste local, incluindo parâmetros como o número de nós e pares de clientes EL/CL específicos, para permitir fluxos de trabalho de desenvolvimento e teste em várias configurações de rede.

O que é Kurtosis?

Kurtosis (opens in a new tab) é um sistema de compilação componível projetado para configurar ambientes de teste de múltiplos contêineres. Ele permite especificamente que os desenvolvedores criem ambientes reprodutíveis que exigem lógica de configuração dinâmica, como redes de teste de blockchain.

Neste guia, o eth-network-package da Kurtosis inicia uma rede de teste local do Ethereum com suporte para o cliente da Camada de Execução (EL) geth (opens in a new tab), bem como para os clientes da Camada de Consenso (CL) teku (opens in a new tab), lighthouse (opens in a new tab) e lodestar (opens in a new tab). Este pacote serve como uma alternativa configurável e componível para redes em frameworks como Hardhat Network, Ganache e Anvil. O Kurtosis oferece aos desenvolvedores maior controle e flexibilidade sobre as redes de teste que utilizam, que é uma das principais razões pelas quais a Ethereum Foundation usou o Kurtosis para testar a Fusão (opens in a new tab) e continua a usá-lo para testar atualizações de rede.

Configurando o Kurtosis

Antes de prosseguir, certifique-se de que você tenha:

Instanciando uma rede de teste local do Ethereum

Para iniciar uma rede de teste local do Ethereum, execute:

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

Observação: Este comando nomeia sua rede: "local-eth-testnet" usando a flag --enclave.

O Kurtosis imprimirá os passos que está a tomar internamente enquanto trabalha para interpretar, validar e executar as instruções. Ao final, você deverá ver um resultado semelhante ao seguinte:

1INFO[2023-04-04T18:09:44-04:00] ======================================================
2INFO[2023-04-04T18:09:44-04:00] ||          Enclave criado: local-eth-testnet      ||
3INFO[2023-04-04T18:09:44-04:00] ======================================================
4Nome:            local-eth-testnet
5UUID:            39372d756ae8
6Status:          EM EXECUÇÃO
7Horário da criação:   Ter, 04 Abr 2023 18:09:03 EDT
8
9========================================= Artefatos de Arquivos =========================================
10UUID           Nome
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========================================== Serviços de Usuário ==========================================
20UUID           Nome                                           Portas                                         Status
21e20f129ee0c5   cl-client-0-beacon                             http: 4000/tcp -> <http://127.0.0.1:54261>    EM EXECUÇÃO
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             EM EXECUÇÃO
26                                                              metrics: 5064/tcp -> <http://127.0.0.1:54268>
27d7b802f623e8   el-client-0                                    engine-rpc: 8551/tcp -> 127.0.0.1:54253       EM EXECUÇÃO
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   <nenhum>                                        PARADO
3362bd62d0aa7a   prelaunch-data-generator-1680646157915424301   <nenhum>                                        PARADO
3405e9619e0e90   prelaunch-data-generator-1680646157922872635   <nenhum>                                        PARADO
35
Exibir tudo

Parabéns! Você usou o Kurtosis para instanciar uma rede de teste local do Ethereum, com um cliente CL (lighthouse) e um cliente EL (geth), sobre Docker.

Revisão

Nesta seção, você executou um comando que instruiu o Kurtosis a usar o eth-network-package hospedado remotamente no GitHub (opens in a new tab) para iniciar uma rede de teste local do Ethereum dentro de um Enclave (opens in a new tab) do Kurtosis. Dentro do seu enclave, você encontrará "artefatos de arquivo" e "serviços de usuário".

Os Artefatos de arquivo (opens in a new tab) no seu enclave incluem todos os dados gerados e utilizados para inicializar os clientes EL e CL. Os dados foram criados usando o serviço prelaunch-data-generator construído a partir desta imagem Docker (opens in a new tab)

Os serviços de usuário exibem todos os serviços em contêineres operando no seu enclave. Você notará que um único nó, com um cliente EL e um cliente CL, foi criado.

Conecte seu ambiente de desenvolvimento de dApp à rede de teste local do Ethereum

Configure o ambiente de desenvolvimento de dApp

Agora que você tem uma rede de teste local em execução, você pode conectar seu ambiente de desenvolvimento de dApp para usar sua rede de teste local. O framework Hardhat será usado neste guia para implantar um dApp de blackjack na sua rede de teste local.

Para configurar seu ambiente de desenvolvimento de dApp, clone o repositório que contém nosso dApp de exemplo e instale suas dependências, execute:

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

A pasta smart-contract-example (opens in a new tab) usada aqui contém a configuração típica para um desenvolvedor de dApp usando o framework Hardhat (opens in a new tab):

Configurar o Hardhat para usar a rede de teste local

Com seu ambiente de desenvolvimento de dApp configurado, você agora conectará o Hardhat para usar a rede de teste local do Ethereum gerada usando o Kurtosis. Para fazer isso, substitua <$YOUR_PORT> na estrutura localnet no seu arquivo de configuração hardhat.config.ts pela porta da saída do URI rpc de qualquer serviço el-client-<num>. Neste caso de exemplo, a porta seria 64248. Sua porta será diferente.

Exemplo em hardhat.config.ts:

1localnet: {
2url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO: SUBSTITUA $YOUR_PORT PELA PORTA DE UM URI DE NÓ PRODUZIDO PELO PACOTE DE REDE ETH KURTOSIS
3
4// Estas são chaves privadas associadas a contas de teste pré-financiadas criadas pelo eth-network-package
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},
Exibir tudo

Depois de salvar seu arquivo, seu ambiente de desenvolvimento de dApp Hardhat está agora conectado à sua rede de teste local do Ethereum! Você pode verificar se sua rede de teste está funcionando executando:

1npx hardhat balances --network localnet

A saída deve ser algo como:

10x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
20x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
30xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
40x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
50x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
60x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000

Isso confirma que o Hardhat está usando sua rede de teste local e detecta as contas pré-financiadas criadas pelo eth-network-package.

Implantar e testar seu dApp localmente

Com o ambiente de desenvolvimento de dApp totalmente conectado à rede de teste local do Ethereum, agora você pode executar fluxos de trabalho de desenvolvimento e teste em seu dApp usando a rede de teste local.

Para compilar e implantar o contrato inteligente ChipToken.sol para prototipagem e desenvolvimento local, execute:

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

A saída deve se parecer com:

1ChipToken implantado em: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d

Agora tente executar o teste simple.js em seu dApp local para confirmar que cada jogador em nosso dApp de Blackjack tem 1000 tokens emitidos para eles:

A saída deve ser algo como:

1npx hardhat test --network localnet

A saída deve ser algo como:

1ChipToken
2    emissão
3      ✔ deve emitir 1000 fichas para o JOGADOR UM
4
5  1 aprovado (654ms)

Revisão

Neste ponto, você configurou um ambiente de desenvolvimento de dApp, conectou-o a uma rede Ethereum local criada pelo Kurtosis e compilou, implantou e executou um teste simples em seu dApp.

Agora vamos explorar como você pode configurar a rede subjacente para testar nossos dApps sob várias configurações de rede.

Configurando a rede de teste local do Ethereum

Alterando as configurações do cliente e o número de nós

Sua rede de teste local do Ethereum pode ser configurada para usar diferentes pares de clientes EL e CL, bem como um número variável de nós, dependendo do cenário e da configuração de rede específica que você deseja desenvolver ou testar. Isso significa que, uma vez configurado, você pode iniciar uma rede de teste local personalizada e usá-la para executar os mesmos fluxos de trabalho (implantação, testes, etc.) sob várias configurações de rede para garantir que tudo funcione como esperado. Para saber mais sobre os outros parâmetros que você pode modificar, visite este link.

Experimente! Você pode passar várias opções de configuração para o eth-network-package através de um arquivo JSON. Este arquivo JSON de parâmetros de rede fornece as configurações específicas que o Kurtosis usará para configurar a rede Ethereum local.

Pegue o arquivo de configuração padrão e edite-o para iniciar três nós com pares EL/CL diferentes:

  • Nó 1 com geth/lighthouse
  • Nó 2 com geth/lodestar
  • Nó 3 com geth/teku

Essa configuração cria uma rede heterogênea de implementações de nós Ethereum para testar seu dApp. Seu arquivo de configuração deve ficar assim:

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}
Exibir tudo

Cada estrutura participants mapeia para um nó na rede, portanto, 3 estruturas participants instruirão o Kurtosis a iniciar 3 nós em sua rede. Cada estrutura participants permitirá que você especifique o par EL e CL usado para aquele nó específico.

A estrutura network_params configura as definições de rede que são usadas para criar os arquivos de gênese para cada nó, bem como outras configurações, como os segundos por slot da rede.

Salve seu arquivo de parâmetros editado em qualquer diretório que desejar (no exemplo abaixo, ele é salvo na área de trabalho) e, em seguida, use-o para executar seu pacote Kurtosis executando:

1kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"

Observação: o comando kurtosis clean -a é usado aqui para instruir o Kurtosis a destruir a antiga rede de teste e seu conteúdo antes de iniciar uma nova.

Novamente, o Kurtosis trabalhará por um tempo e imprimirá os passos individuais que estão ocorrendo. Eventualmente, a saída deve ser algo como:

1Código Starlark executado com sucesso. Nenhum resultado foi retornado.
2INFO[2023-04-07T11:43:16-04:00] ==========================================================
3INFO[2023-04-07T11:43:16-04:00] ||          Enclave criado: local-eth-testnet          ||
4INFO[2023-04-07T11:43:16-04:00] ==========================================================
5Nome:            local-eth-testnet
6UUID:            bef8c192008e
7Status:          EM EXECUÇÃO
8Horário de criação:   Sex, 07 Abr 2023 11:41:58 EDT
9
10========================================= Artefatos de Arquivos =========================================
11UUID           Nome
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========================================== Serviços de Usuário ==========================================
23UUID           Nome                                           Portas                                            Status
24485e6fde55ae   cl-client-0-beacon                             http: 4000/tcp -> http://127.0.0.1:65010         EM EXECUÇÃO
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                EM EXECUÇÃO
29                                                              metrics: 5064/tcp -> http://127.0.0.1:65017
301b0a233cd011   cl-client-1-beacon                             http: 4000/tcp -> 127.0.0.1:65021                EM EXECUÇÃO
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                EM EXECUÇÃO
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                EM EXECUÇÃO
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          EM EXECUÇÃO
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          EM EXECUÇÃO
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          EM EXECUÇÃO
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   <nenhum>                                           PARADO
605b45f9c0504b   prelaunch-data-generator-1680882122192182847   <nenhum>                                           PARADO
613d4aaa75e218   prelaunch-data-generator-1680882122201668972   <nenhum>                                           PARADO
Exibir tudo

Parabéns! Você configurou com sucesso sua rede de teste local para ter 3 nós em vez de 1. Para executar os mesmos fluxos de trabalho que você fez antes em seu dApp (implantar e testar), realize as mesmas operações que fizemos antes, substituindo <$YOUR_PORT> na estrutura localnet em seu arquivo de configuração hardhat.config.ts pela porta da saída do URI rpc de qualquer serviço el-client-<num> em sua nova rede de teste local de 3 nós.

Conclusão

E é isso! Para recapitular este breve guia, você:

  • Criou uma rede de teste local do Ethereum sobre Docker usando o Kurtosis
  • Conectou seu ambiente de desenvolvimento de dApp local à rede Ethereum local
  • Implantou um dApp e executou um teste simples nele na rede Ethereum local
  • Configurou a rede Ethereum subjacente para ter 3 nós

Gostaríamos muito de saber sua opinião sobre o que deu certo para você, o que poderia ser melhorado, ou para responder a qualquer uma de suas perguntas. Não hesite em nos contatar via GitHub (opens in a new tab) ou envie-nos um e-mail (opens email client)!

Outros exemplos e guias

Nós o encorajamos a conferir nosso início rápido (opens in a new tab) (onde você construirá um banco de dados Postgres e uma API sobre ele) e nossos outros exemplos em nosso repositório awesome-kurtosis (opens in a new tab) onde você encontrará ótimos exemplos, incluindo pacotes para:

Última atualização da página: 23 de setembro de 2025

mdqstm (opens in a new tab)
brossetti1b (opens in a new tab)
pettinaripp (opens in a new tab)
+2

Este tutorial foi útil?