Comment développer et tester une dapp sur un réseau de test local multi-clients

clients

nœuds

contrats intelligents

composabilité

couche de consensus

couche d'exécution

tests

Intermédiaire

Tedi Mitiku

11 avril 2023

12 minutes de lecture

Introduction

Ce guide vous accompagne dans le processus d'instanciation d'un réseau de test Ethereum local configurable, de déploiement d'un contrat intelligent sur celui-ci, et d'utilisation du réseau de test pour exécuter des tests sur votre application décentralisée (dapp). Ce guide est conçu pour les développeurs de dapps qui souhaitent développer et tester leurs dapps localement avec différentes configurations de réseau avant de les déployer sur un réseau de test en direct ou sur le Réseau principal.

Dans ce guide, vous allez :

Instancier un réseau de test Ethereum local avec le eth-network-package (opens in a new tab) en utilisant Kurtosis (opens in a new tab),
Connecter votre environnement de développement de dapp Hardhat au réseau de test local pour compiler, déployer et tester une dapp, et
Configurer le réseau de test local, y compris des paramètres tels que le nombre de nœuds et les paires spécifiques de clients de la couche d'exécution (EL) et de la couche de consensus (CL), pour permettre des flux de développement et de test sur diverses configurations de réseau.

Qu'est-ce que Kurtosis ?

Kurtosis (opens in a new tab) est un système de construction composable conçu pour configurer des environnements de test multi-conteneurs. Il permet spécifiquement aux développeurs de créer des environnements reproductibles qui nécessitent une logique de configuration dynamique, tels que les réseaux de test de chaîne de blocs.

Dans ce guide, le paquet eth-network-package de Kurtosis lance un réseau de test Ethereum local prenant en charge le client de la couche d'exécution (EL) geth (opens in a new tab), ainsi que les clients de la couche de consensus (CL) teku (opens in a new tab), lighthouse (opens in a new tab) et lodestar (opens in a new tab). Ce paquet sert d'alternative configurable et composable aux réseaux dans des frameworks comme Hardhat Network, Ganache et Anvil. Kurtosis offre aux développeurs un contrôle et une flexibilité accrus sur les réseaux de test qu'ils utilisent, ce qui est l'une des principales raisons pour lesquelles la Fondation Ethereum a utilisé Kurtosis pour tester La Fusion (opens in a new tab) et continue de l'utiliser pour tester les mises à niveau du réseau.

Configuration de Kurtosis

Avant de continuer, assurez-vous d'avoir :

Installé et démarré le moteur Docker (opens in a new tab) sur votre machine locale
Installé l'interface en ligne de commande (CLI) Kurtosis (opens in a new tab) (ou l'avoir mise à jour vers la dernière version, si vous l'avez déjà installée)
Installé Node.js (opens in a new tab), yarn (opens in a new tab) et npx (opens in a new tab) (pour votre environnement de dapp)

Instanciation d'un réseau de test Ethereum local

Pour lancer un réseau de test Ethereum local, exécutez :

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

Remarque : Cette commande nomme votre réseau « local-eth-testnet » en utilisant l'indicateur --enclave.

Kurtosis affichera les étapes qu'il effectue en arrière-plan pendant qu'il interprète, valide, puis exécute les instructions. À la fin, vous devriez voir une sortie qui ressemble à ce qui suit :

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

Félicitations ! Vous avez utilisé Kurtosis pour instancier un réseau de test Ethereum local, avec un client de la couche de consensus (CL) (lighthouse) et un client de la couche d'exécution (EL) (geth), via Docker.

Bilan

Dans cette section, vous avez exécuté une commande qui a ordonné à Kurtosis d'utiliser le eth-network-package hébergé à distance sur GitHub (opens in a new tab) pour lancer un réseau de test Ethereum local au sein d'une Enclave (opens in a new tab) Kurtosis. À l'intérieur de votre enclave, vous trouverez à la fois des « artefacts de fichiers » et des « services utilisateur ».

Les Artefacts de fichiers (opens in a new tab) dans votre enclave incluent toutes les données générées et utilisées pour amorcer les clients EL et CL. Les données ont été créées à l'aide du service prelaunch-data-generator construit à partir de cette image Docker (opens in a new tab).

Les services utilisateur affichent tous les services conteneurisés fonctionnant dans votre enclave. Vous remarquerez qu'un seul nœud, comprenant à la fois un client EL et un client CL, a été créé.

Connecter votre environnement de développement de dapp au réseau de test Ethereum local

Configurer l'environnement de développement de dapp

Maintenant que vous avez un réseau de test local en cours d'exécution, vous pouvez connecter votre environnement de développement d'application décentralisée (dapp) pour utiliser votre réseau de test local. Le framework Hardhat sera utilisé dans ce guide pour déployer une dapp de blackjack sur votre réseau de test local.

Pour configurer votre environnement de développement de dapp, clonez le dépôt qui contient notre dapp d'exemple et installez ses dépendances, exécutez :

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

Le dossier smart-contract-example (opens in a new tab) utilisé ici contient la configuration typique pour un développeur de dapp utilisant le framework Hardhat (opens in a new tab) :

contracts/ (opens in a new tab) contient quelques contrats intelligents simples pour une dapp de Blackjack
scripts/ (opens in a new tab) contient un script pour déployer un contrat de jeton sur votre réseau Ethereum local
test/ (opens in a new tab) contient un test .js simple pour votre contrat de jeton afin de confirmer que chaque joueur de notre dapp de Blackjack a 1000 jetons émis pour lui
hardhat.config.ts (opens in a new tab) configure votre installation Hardhat

Configurer Hardhat pour utiliser le réseau de test local

Avec votre environnement de développement de dapp configuré, vous allez maintenant connecter Hardhat pour utiliser le réseau de test Ethereum local généré à l'aide de Kurtosis. Pour ce faire, remplacez <$YOUR_PORT> dans la structure localnet de votre fichier de configuration hardhat.config.ts par le port de l'URI RPC généré par n'importe quel service el-client-<num>. Dans cet exemple, le port serait 64248. Votre port sera différent.

Exemple dans hardhat.config.ts :

localnet: {
url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO : REMPLACER $YOUR_PORT PAR LE PORT D'UNE URI DE NŒUD PRODUITE PAR LE PAQUET ETH NETWORK KURTOSIS

// Ce sont des clés privées associées à des comptes de test préfinancés créés par le 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",
  ],
},

Une fois votre fichier enregistré, votre environnement de développement de dapp Hardhat est maintenant connecté à votre réseau de test Ethereum local ! Vous pouvez vérifier que votre réseau de test fonctionne en exécutant :

npx hardhat balances --network localnet

La sortie devrait ressembler à ceci :

0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000

Cela confirme que Hardhat utilise votre réseau de test local et détecte les comptes préfinancés créés par le eth-network-package.

Déployer et tester votre dapp localement

Avec l'environnement de développement de dapp entièrement connecté au réseau de test Ethereum local, vous pouvez maintenant exécuter des flux de développement et de test sur votre dapp en utilisant le réseau de test local.

Pour compiler et déployer le contrat intelligent ChipToken.sol pour le prototypage et le développement locaux, exécutez :

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

La sortie devrait ressembler à :

ChipToken deployed to: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d

Essayez maintenant d'exécuter le test simple.js sur votre dapp locale pour confirmer que chaque joueur de notre dapp de Blackjack a 1000 jetons émis pour lui :

La sortie devrait ressembler à ceci :

npx hardhat test --network localnet

La sortie devrait ressembler à ceci :

ChipToken
    mint
      ✔ should mint 1000 chips for PLAYER ONE

  1 passing (654ms)

Bilan

À ce stade, vous avez configuré un environnement de développement de dapp, vous l'avez connecté à un réseau Ethereum local créé par Kurtosis, et vous avez compilé, déployé et exécuté un test simple sur votre dapp.

Explorons maintenant comment vous pouvez configurer le réseau sous-jacent pour tester nos dapps sous diverses configurations de réseau.

Configuration du réseau de test Ethereum local

Modification des configurations des clients et du nombre de nœuds

Votre réseau de test Ethereum local peut être configuré pour utiliser différentes paires de clients EL et CL, ainsi qu'un nombre variable de nœuds, en fonction du scénario et de la configuration réseau spécifique que vous souhaitez développer ou tester. Cela signifie qu'une fois configuré, vous pouvez lancer un réseau de test local personnalisé et l'utiliser pour exécuter les mêmes flux de travail (déploiement, tests, etc.) sous diverses configurations de réseau pour vous assurer que tout fonctionne comme prévu. Pour en savoir plus sur les autres paramètres que vous pouvez modifier, visitez ce lien.

Essayez ! Vous pouvez transmettre diverses options de configuration au eth-network-package via un fichier JSON. Ce fichier JSON de paramètres réseau fournit les configurations spécifiques que Kurtosis utilisera pour configurer le réseau Ethereum local.

Prenez le fichier de configuration par défaut et modifiez-le pour lancer deux nœuds avec des paires EL/CL différentes :

Nœud 1 avec geth/lighthouse
Nœud 2 avec geth/lodestar
Nœud 3 avec geth/teku

Cette configuration crée un réseau hétérogène d'implémentations de nœuds Ethereum pour tester votre dapp. Votre fichier de configuration devrait maintenant ressembler à :

{
  "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,
    },
}

Chaque structure participants correspond à un nœud du réseau, donc 3 structures participants indiqueront à Kurtosis de lancer 3 nœuds dans votre réseau. Chaque structure participants vous permettra de spécifier la paire EL et CL utilisée pour ce nœud spécifique.

La structure network_params configure les paramètres réseau qui sont utilisés pour créer les fichiers de genèse pour chaque nœud, ainsi que d'autres paramètres comme les secondes par créneau du réseau.

Enregistrez votre fichier de paramètres modifié dans le répertoire de votre choix (dans l'exemple ci-dessous, il est enregistré sur le bureau), puis utilisez-le pour exécuter votre paquet Kurtosis en lançant :

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

Remarque : la commande kurtosis clean -a est utilisée ici pour indiquer à Kurtosis de détruire l'ancien réseau de test et son contenu avant d'en démarrer un nouveau.

Encore une fois, Kurtosis travaillera un moment et affichera les étapes individuelles qui se déroulent. Finalement, la sortie devrait ressembler à :

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

Félicitations ! Vous avez configuré avec succès votre réseau de test local pour avoir 3 nœuds au lieu de 1. Pour exécuter les mêmes flux de travail que précédemment sur votre dapp (déployer et tester), effectuez les mêmes opérations que nous avons faites auparavant en remplaçant le <$YOUR_PORT> dans la structure localnet de votre fichier de configuration hardhat.config.ts par le port de l'URI RPC généré par n'importe quel service el-client-<num> dans votre nouveau réseau de test local à 3 nœuds.

Conclusion

Et c'est tout ! Pour résumer ce court guide, vous avez :

Créé un réseau de test Ethereum local via Docker en utilisant Kurtosis
Connecté votre environnement de développement de dapp local au réseau Ethereum local
Déployé une dapp et exécuté un test simple sur celle-ci sur le réseau Ethereum local
Configuré le réseau Ethereum sous-jacent pour avoir 3 nœuds

Nous serions ravis de savoir ce qui s'est bien passé pour vous, ce qui pourrait être amélioré, ou de répondre à vos questions. N'hésitez pas à nous contacter via GitHub (opens in a new tab) ou à nous envoyer un e-mail (opens email client) !

Autres exemples et guides

Nous vous encourageons à consulter notre guide de démarrage rapide (opens in a new tab) (où vous construirez une base de données Postgres et une API par-dessus) et nos autres exemples dans notre dépôt awesome-kurtosis (opens in a new tab) où vous trouverez d'excellents exemples, y compris des paquets pour :

Lancer le même réseau de test Ethereum local (opens in a new tab), mais avec des services supplémentaires connectés tels qu'un spammeur de transactions (pour simuler des transactions), un moniteur de fork, et une instance Grafana et Prometheus connectée
Effectuer un test de sous-réseau (opens in a new tab) sur le même réseau Ethereum local