Vai al contenuto principale

Come sviluppare e testare una dApp su una rete di test locale multi-client

client
nodi
contratti intelligenti
componibilità
livello di consenso
livello di esecuzione
test
Intermedio
Tedi Mitiku
11 aprile 2023
12 minuti di lettura

Introduzione

Questa guida ti accompagna nel processo di istanziazione di una rete di test locale e configurabile di Ethereum, di distribuzione di un contratto intelligente su di essa e di utilizzo della rete di test per eseguire test sulla tua dApp. Questa guida è progettata per gli sviluppatori di dApp che desiderano sviluppare e testare le proprie dApp localmente su diverse configurazioni di rete prima di distribuirle su una rete di test attiva o sulla rete principale.

In questa guida, potrai:

  • Istanziare una rete di test locale di Ethereum con l'eth-network-package (opens in a new tab) utilizzando Kurtosis (opens in a new tab),
  • Connettere il tuo ambiente di sviluppo di dApp Hardhat alla rete di test locale per compilare, distribuire e testare una dApp, e
  • Configurare la rete di test locale, inclusi parametri come il numero di nodi e specifici abbinamenti di client EL/CL, per abilitare flussi di lavoro di sviluppo e test su varie configurazioni di rete.

Cos'è Kurtosis?

Kurtosis (opens in a new tab) è un sistema di compilazione componibile progettato per configurare ambienti di test multi-container. Consente specificamente agli sviluppatori di creare ambienti riproducibili che richiedono logiche di configurazione dinamiche, come le reti di test blockchain.

In questa guida, l'eth-network-package di Kurtosis avvia una rete di test locale di Ethereum con supporto per il client del livello di esecuzione (EL) geth (opens in a new tab), oltre ai client del livello di consenso (CL) teku (opens in a new tab), lighthouse (opens in a new tab) e lodestar (opens in a new tab). Questo pacchetto funge da alternativa configurabile e componibile alle reti in framework come Hardhat Network, Ganache e Anvil. Kurtosis offre agli sviluppatori un maggiore controllo e flessibilità sulle reti di test che utilizzano, che è uno dei motivi principali per cui la Fondazione Ethereum ha utilizzato Kurtosis per testare il Merge (opens in a new tab) e continua a utilizzarlo per testare gli aggiornamenti della rete.

Configurare Kurtosis

Prima di procedere, assicurati di aver:

Istanziare una rete di test locale di Ethereum

Per avviare una rete di test locale di Ethereum, esegui:

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

Nota: questo comando nomina la tua rete: "local-eth-testnet" utilizzando il flag --enclave.

Kurtosis stamperà i passaggi che sta eseguendo in background mentre lavora per interpretare, convalidare e quindi eseguire le istruzioni. Alla fine, dovresti vedere un output simile al seguente:

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
Mostra tutto

Congratulazioni! Hai utilizzato Kurtosis per istanziare una rete di test locale di Ethereum, con un client CL (lighthouse) ed EL (geth), su Docker.

Revisione

In questa sezione, hai eseguito un comando che ha indicato a Kurtosis di utilizzare l'eth-network-package ospitato in remoto su GitHub (opens in a new tab) per avviare una rete di test locale di Ethereum all'interno di un'Enclave (opens in a new tab) di Kurtosis. All'interno della tua enclave, troverai sia "artefatti di file" che "servizi utente".

Gli Artefatti di File (opens in a new tab) nella tua enclave includono tutti i dati generati e utilizzati per avviare i client EL e CL. I dati sono stati creati utilizzando il servizio prelaunch-data-generator creato da questa immagine Docker (opens in a new tab)

I servizi utente mostrano tutti i servizi containerizzati operativi nella tua enclave. Noterai che è stato creato un singolo nodo, che presenta sia un client EL che un client CL.

Connettere il tuo ambiente di sviluppo di dApp alla rete di test locale di Ethereum

Configurare l'ambiente di sviluppo della dApp

Ora che hai una rete di test locale in esecuzione, puoi connettere il tuo ambiente di sviluppo di dApp per utilizzare la tua rete di test locale. Il framework Hardhat verrà utilizzato in questa guida per distribuire una dApp di blackjack sulla tua rete di test locale.

Per configurare il tuo ambiente di sviluppo di dApp, clona il repository che contiene la nostra dApp di esempio e installa le sue dipendenze, esegui:

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

La cartella smart-contract-example (opens in a new tab) utilizzata qui contiene la configurazione tipica per uno sviluppatore di dApp che utilizza il framework Hardhat (opens in a new tab):

Configurare Hardhat per utilizzare la rete di test locale

Con il tuo ambiente di sviluppo di dApp configurato, ora connetterai Hardhat per utilizzare la rete di test locale di Ethereum generata utilizzando Kurtosis. Per farlo, sostituisci <$YOUR_PORT> nella struttura localnet nel tuo file di configurazione hardhat.config.ts con la porta dell'URI RPC in output da qualsiasi servizio el-client-<num>. In questo caso di esempio, la porta sarebbe 64248. La tua porta sarà diversa.

Esempio in hardhat.config.ts:

1localnet: {
2url: 'http://127.0.0.1:<$YOUR_PORT>', // TODO: SOSTITUISCI $YOUR_PORT CON LA PORTA DI UN URI DEL NODO PRODOTTO DAL PACCHETTO ETH NETWORK KURTOSIS
3
4// Queste sono chiavi private associate ad account di test prefinanziati creati dall'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},
Mostra tutto

Una volta salvato il file, il tuo ambiente di sviluppo di dApp Hardhat è ora connesso alla tua rete di test locale di Ethereum! Puoi verificare che la tua rete di test funzioni eseguendo:

1npx hardhat balances --network localnet

L'output dovrebbe essere simile a questo:

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

Questo conferma che Hardhat sta utilizzando la tua rete di test locale e rileva gli account prefinanziati creati dall'eth-network-package.

Distribuire e testare la tua dApp localmente

Con l'ambiente di sviluppo della dApp completamente connesso alla rete di test locale di Ethereum, ora puoi eseguire flussi di lavoro di sviluppo e test sulla tua dApp utilizzando la rete di test locale.

Per compilare e distribuire il contratto intelligente ChipToken.sol per la prototipazione e lo sviluppo locale, esegui:

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

L'output dovrebbe essere simile a:

1ChipToken deployed to: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d

Ora prova a eseguire il test simple.js sulla tua dApp locale per confermare che ogni giocatore nella nostra dApp di Blackjack abbia 1000 token coniati per loro:

L'output dovrebbe essere simile a questo:

1npx hardhat test --network localnet

L'output dovrebbe essere simile a questo:

1ChipToken
2    mint
3      ✔ should mint 1000 chips for PLAYER ONE
4
5  1 passing (654ms)

Revisione

A questo punto, hai configurato un ambiente di sviluppo di dApp, lo hai connesso a una rete locale di Ethereum creata da Kurtosis e hai compilato, distribuito ed eseguito un semplice test sulla tua dApp.

Ora esploriamo come puoi configurare la rete sottostante per testare le nostre dApp in diverse configurazioni di rete.

Configurare la rete di test locale di Ethereum

Modificare le configurazioni dei client e il numero di nodi

La tua rete di test locale di Ethereum può essere configurata per utilizzare diverse coppie di client EL e CL, oltre a un numero variabile di nodi, a seconda dello scenario e della specifica configurazione di rete che desideri sviluppare o testare. Ciò significa che, una volta configurata, puoi avviare una rete di test locale personalizzata e utilizzarla per eseguire gli stessi flussi di lavoro (distribuzione, test, ecc.) in varie configurazioni di rete per assicurarti che tutto funzioni come previsto. Per saperne di più sugli altri parametri che puoi modificare, visita questo link.

Fai una prova! Puoi passare varie opzioni di configurazione all'eth-network-package tramite un file JSON. Questo file JSON dei parametri di rete fornisce le configurazioni specifiche che Kurtosis utilizzerà per configurare la rete locale di Ethereum.

Prendi il file di configurazione predefinito e modificalo per avviare due nodi con diverse coppie EL/CL:

  • Nodo 1 con geth/lighthouse
  • Nodo 2 con geth/lodestar
  • Nodo 3 con geth/teku

Questa configurazione crea una rete eterogenea di implementazioni di nodi Ethereum per testare la tua dApp. Il tuo file di configurazione dovrebbe ora apparire così:

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}
Mostra tutto

Ogni struttura participants è mappata a un nodo nella rete, quindi 3 strutture participants diranno a Kurtosis di avviare 3 nodi nella tua rete. Ogni struttura participants ti consentirà di specificare la coppia EL e CL utilizzata per quel nodo specifico.

La struttura network_params configura le impostazioni di rete che vengono utilizzate per creare i file di genesi per ogni nodo, oltre ad altre impostazioni come i secondi per slot della rete.

Salva il tuo file dei parametri modificato in qualsiasi directory desideri (nell'esempio seguente, è salvato sul desktop) e quindi utilizzalo per eseguire il tuo pacchetto Kurtosis eseguendo:

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

Nota: il comando kurtosis clean -a viene utilizzato qui per istruire Kurtosis a distruggere la vecchia rete di test e i suoi contenuti prima di avviarne una nuova.

Ancora una volta, Kurtosis lavorerà per un po' e stamperà i singoli passaggi che stanno avendo luogo. Alla fine, l'output dovrebbe essere simile a:

1Starlark code successfully run. No output was returned.
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
Mostra tutto

Congratulazioni! Hai configurato con successo la tua rete di test locale per avere 3 nodi invece di 1. Per eseguire gli stessi flussi di lavoro che hai fatto prima sulla tua dApp (distribuzione e test), esegui le stesse operazioni che abbiamo fatto prima sostituendo <$YOUR_PORT> nella struttura localnet nel tuo file di configurazione hardhat.config.ts con la porta dell'URI RPC in output da qualsiasi servizio el-client-<num> nella tua nuova rete di test locale a 3 nodi.

Conclusione

E questo è tutto! Per riassumere questa breve guida, hai:

  • Creato una rete di test locale di Ethereum su Docker utilizzando Kurtosis
  • Connesso il tuo ambiente di sviluppo di dApp locale alla rete locale di Ethereum
  • Distribuito una dApp ed eseguito un semplice test su di essa sulla rete locale di Ethereum
  • Configurato la rete Ethereum sottostante per avere 3 nodi

Ci piacerebbe sapere da te cosa è andato bene, cosa potrebbe essere migliorato o rispondere a qualsiasi tua domanda. Non esitare a contattarci tramite GitHub (opens in a new tab) o inviaci un'e-mail (opens email client)!

Altri esempi e guide

Ti invitiamo a dare un'occhiata alla nostra guida rapida (opens in a new tab) (dove costruirai un database Postgres e un'API su di esso) e ai nostri altri esempi nel nostro repository awesome-kurtosis (opens in a new tab) dove troverai alcuni ottimi esempi, inclusi pacchetti per:

Ultimo aggiornamento della pagina: 23 settembre 2025

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

Questo tutorial è stato utile?