Post merge local testnets (sigp#3807)

pawanjay176 · Woodpile37 · commit 4edf71bb2ebb · 2024-01-06T07:02:49.000-06:00
N/A

Modifies the local testnet scripts to start a network with genesis validators embedded into the genesis state. This allows us to start a local testnet without the need for deploying a deposit contract or depositing validators pre-genesis.

This also enables us to start a local test network at any fork we want without going through fork transitions. Also adds scripts to start multiple geth clients and peer them with each other and peer the geth clients with beacon nodes to start a post merge local testnet.

Adds a new lcli command `mnemonics-validators` that generates validator directories derived from a given mnemonic.
Adds a new `derived-genesis-state` option to the `lcli new-testnet` command to generate a genesis state populated with validators derived from a mnemonic.
diff --git a/.github/workflows/test-suite.yml b/.github/workflows/test-suite.yml
@@ -228,8 +228,6 @@ jobs:
       uses: arduino/setup-protoc@e52d9eb8f7b63115df1ac544a1376fdbf5a39612
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
-    - name: Install anvil
-      run: cargo install --git https://github.com/foundry-rs/foundry --locked anvil
     - name: Run the beacon chain sim without an eth1 connection
       run: cargo run --release --bin simulator no-eth1-sim
   syncing-simulator-ubuntu:
@@ -260,20 +258,23 @@ jobs:
       uses: arduino/setup-protoc@e52d9eb8f7b63115df1ac544a1376fdbf5a39612
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
-    - name: Install anvil
-      run: cargo install --git https://github.com/foundry-rs/foundry --locked anvil
+    - name: Install geth
+      run: |
+          sudo add-apt-repository -y ppa:ethereum/ethereum
+          sudo apt-get update
+          sudo apt-get install ethereum
     - name: Install lighthouse and lcli
       run: |
           make
           make install-lcli
-    - name: Run the doppelganger protection success test script
+    - name: Run the doppelganger protection failure test script
       run: |
           cd scripts/tests
-          ./doppelganger_protection.sh success
-    - name: Run the doppelganger protection failure test script
+          ./doppelganger_protection.sh failure genesis.json
+    - name: Run the doppelganger protection success test script
       run: |
           cd scripts/tests
-          ./doppelganger_protection.sh failure
+          ./doppelganger_protection.sh success genesis.json
   execution-engine-integration-ubuntu:
     name: execution-engine-integration-ubuntu
     runs-on: ubuntu-latest
diff --git a/lcli/src/mnemonic_validators.rs b/lcli/src/mnemonic_validators.rs
@@ -0,0 +1,104 @@
+use account_utils::eth2_keystore::{keypair_from_secret, Keystore, KeystoreBuilder};
+use account_utils::random_password;
+use clap::ArgMatches;
+use eth2_wallet::bip39::Seed;
+use eth2_wallet::bip39::{Language, Mnemonic};
+use eth2_wallet::{recover_validator_secret_from_mnemonic, KeyType};
+use rayon::prelude::*;
+use std::fs;
+use std::path::PathBuf;
+use validator_dir::Builder as ValidatorBuilder;
+
+/// Generates validator directories with keys derived from the given mnemonic.
+pub fn generate_validator_dirs(
+    indices: &[usize],
+    mnemonic_phrase: &str,
+    validators_dir: PathBuf,
+    secrets_dir: PathBuf,
+) -> Result<(), String> {
+    if !validators_dir.exists() {
+        fs::create_dir_all(&validators_dir)
+            .map_err(|e| format!("Unable to create validators dir: {:?}", e))?;
+    }
+
+    if !secrets_dir.exists() {
+        fs::create_dir_all(&secrets_dir)
+            .map_err(|e| format!("Unable to create secrets dir: {:?}", e))?;
+    }
+    let mnemonic = Mnemonic::from_phrase(mnemonic_phrase, Language::English).map_err(|e| {
+        format!(
+            "Unable to derive mnemonic from string {:?}: {:?}",
+            mnemonic_phrase, e
+        )
+    })?;
+
+    let seed = Seed::new(&mnemonic, "");
+
+    let _: Vec<_> = indices
+        .par_iter()
+        .map(|index| {
+            let voting_password = random_password();
+
+            let derive = |key_type: KeyType, password: &[u8]| -> Result<Keystore, String> {
+                let (secret, path) = recover_validator_secret_from_mnemonic(
+                    seed.as_bytes(),
+                    *index as u32,
+                    key_type,
+                )
+                .map_err(|e| format!("Unable to recover validator keys: {:?}", e))?;
+
+                let keypair = keypair_from_secret(secret.as_bytes())
+                    .map_err(|e| format!("Unable build keystore: {:?}", e))?;
+
+                KeystoreBuilder::new(&keypair, password, format!("{}", path))
+                    .map_err(|e| format!("Unable build keystore: {:?}", e))?
+                    .build()
+                    .map_err(|e| format!("Unable build keystore: {:?}", e))
+            };
+
+            let voting_keystore = derive(KeyType::Voting, voting_password.as_bytes()).unwrap();
+
+            println!("Validator {}", index + 1);
+
+            ValidatorBuilder::new(validators_dir.clone())
+                .password_dir(secrets_dir.clone())
+                .store_withdrawal_keystore(false)
+                .voting_keystore(voting_keystore, voting_password.as_bytes())
+                .build()
+                .map_err(|e| format!("Unable to build validator: {:?}", e))
+                .unwrap()
+        })
+        .collect();
+
+    Ok(())
+}
+
+pub fn run(matches: &ArgMatches) -> Result<(), String> {
+    let validator_count: usize = clap_utils::parse_required(matches, "count")?;
+    let base_dir: PathBuf = clap_utils::parse_required(matches, "base-dir")?;
+    let node_count: Option<usize> = clap_utils::parse_optional(matches, "node-count")?;
+    let mnemonic_phrase: String = clap_utils::parse_required(matches, "mnemonic-phrase")?;
+    if let Some(node_count) = node_count {
+        let validators_per_node = validator_count / node_count;
+        let validator_range = (0..validator_count).collect::<Vec<_>>();
+        let indices_range = validator_range
+            .chunks(validators_per_node)
+            .collect::<Vec<_>>();
+
+        for (i, indices) in indices_range.iter().enumerate() {
+            let validators_dir = base_dir.join(format!("node_{}", i + 1)).join("validators");
+            let secrets_dir = base_dir.join(format!("node_{}", i + 1)).join("secrets");
+            generate_validator_dirs(indices, &mnemonic_phrase, validators_dir, secrets_dir)?;
+        }
+    } else {
+        let validators_dir = base_dir.join("validators");
+        let secrets_dir = base_dir.join("secrets");
+        generate_validator_dirs(
+            (0..validator_count).collect::<Vec<_>>().as_slice(),
+            &mnemonic_phrase,
+            validators_dir,
+            secrets_dir,
+        )?;
+    }
+    Ok(())
+}
diff --git a/scripts/local_testnet/README.md b/scripts/local_testnet/README.md
@@ -1,11 +1,16 @@
 # Simple Local Testnet
 
-These scripts allow for running a small local testnet with multiple beacon nodes and validator clients.
+These scripts allow for running a small local testnet with multiple beacon nodes and validator clients and a geth execution client.
 This setup can be useful for testing and development.
 
 ## Requirements
 
-The scripts require `lcli` and `lighthouse` to be installed on `PATH`. From the
+The scripts require `lcli`, `lighthouse`, `geth`, `bootnode` to be installed on `PATH`.
+
+
+MacOS users need to install GNU `sed` and GNU `grep`, and add them both to `PATH` as well.
+
+From the
 root of this repository, run:
 
 ```bash
@@ -17,17 +22,23 @@ make install-lcli
 
 Modify `vars.env` as desired.
 
-Start a local eth1 anvil server plus boot node along with `BN_COUNT`
-number of beacon nodes and `VC_COUNT` validator clients.
+The testnet starts with a post-merge genesis state. 
+Start a consensus layer and execution layer boot node along with `BN_COUNT`
+number of beacon nodes each connected to a geth execution client and `VC_COUNT` validator clients.
+
+The `start_local_testnet.sh` script takes four options `-v VC_COUNT`, `-d DEBUG_LEVEL`, `-p` to enable builder proposals and `-h` for help. It also takes a mandatory `GENESIS_FILE` for initialising geth's state.
+A sample `genesis.json` is provided in this directory.
+
+The `ETH1_BLOCK_HASH` environment variable is set to the block_hash of the genesis execution layer block which depends on the contents of `genesis.json`. Users of these scripts need to ensure that the `ETH1_BLOCK_HASH` variable is updated if genesis file is modified.
 
-The `start_local_testnet.sh` script takes four options `-v VC_COUNT`, `-d DEBUG_LEVEL`, `-p` to enable builder proposals and `-h` for help.
 The options may be in any order or absent in which case they take the default value specified.
 - VC_COUNT: the number of validator clients to create, default: `BN_COUNT`
 - DEBUG_LEVEL: one of { error, warn, info, debug, trace }, default: `info`
 
 
+
 ```bash
-./start_local_testnet.sh
+./start_local_testnet.sh genesis.json
 ```
 
 ## Stopping the testnet
@@ -41,31 +52,38 @@ This is not necessary before `start_local_testnet.sh` as it invokes `stop_local_
 
 These scripts are used by ./start_local_testnet.sh and may be used to manually
 
-Start a local eth1 anvil server
+Assuming you are happy with the configuration in `vars.env`,
+create the testnet directory, genesis state with embedded validators and validator keys with:
+
 ```bash
-./anvil_test_node.sh
+./setup.sh
 ```
 
-Assuming you are happy with the configuration in `vars.env`, deploy the deposit contract, make deposits,
-create the testnet directory, genesis state and validator keys with:
+Note: The generated genesis validators are embedded into the genesis state as genesis validators and hence do not require manual deposits to activate.
 
+Generate bootnode enr and start an EL and CL bootnode so that multiple nodes can find each other
 ```bash
-./setup.sh
+./bootnode.sh
+./el_bootnode.sh
 ```
 
-Generate bootnode enr and start a discv5 bootnode so that multiple beacon nodes can find each other
+Start a geth node:
 ```bash
-./bootnode.sh
+./geth.sh <DATADIR> <NETWORK-PORT> <HTTP-PORT> <AUTH-HTTP-PORT> <GENESIS_FILE>
+```
+e.g.
+```bash
+./geth.sh $HOME/.lighthouse/local-testnet/geth_1 5000 6000 7000 genesis.json
 ```
 
 Start a beacon node:
 
 ```bash
-./beacon_node.sh <DATADIR> <NETWORK-PORT> <HTTP-PORT> <OPTIONAL-DEBUG-LEVEL>
+./beacon_node.sh <DATADIR> <NETWORK-PORT> <HTTP-PORT> <EXECUTION-ENDPOINT> <EXECUTION-JWT-PATH> <OPTIONAL-DEBUG-LEVEL>
 ```
 e.g.
 ```bash
-./beacon_node.sh $HOME/.lighthouse/local-testnet/node_1 9000 8000
+./beacon_node.sh $HOME/.lighthouse/local-testnet/node_1 9000 8000 http://localhost:6000 ~/.lighthouse/local-testnet/geth_1/geth/jwtsecret
 ```
 
 In a new terminal, start the validator client which will attach to the first
diff --git a/scripts/local_testnet/beacon_node.sh b/scripts/local_testnet/beacon_node.sh
@@ -53,6 +53,7 @@ exec $lighthouse_binary \
 	--datadir $data_dir \
 	--testnet-dir $TESTNET_DIR \
 	--enable-private-discovery \
+  --disable-peer-scoring \
 	--staking \
 	--enr-address 127.0.0.1 \
 	--enr-udp-port $network_port \
diff --git a/scripts/tests/doppelganger_protection.sh b/scripts/tests/doppelganger_protection.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Requires `lighthouse`, ``lcli`, `anvil`, `curl`, `jq`
+# Requires `lighthouse`, `lcli`, `geth`, `bootnode`, `curl`, `jq`
 
 
 BEHAVIOR=$1
@@ -15,21 +15,15 @@ exit_if_fails() {
     $@
     EXIT_CODE=$?
     if [[ $EXIT_CODE -eq 1 ]]; then
-        exit 111
+        exit 1
     fi
 }
+genesis_file=$2
 
 source ./vars.env
 
 exit_if_fails ../local_testnet/clean.sh
 
-echo "Starting anvil"
-
-exit_if_fails ../local_testnet/anvil_test_node.sh &> /dev/null &
-ANVIL_PID=$!
-
-# Wait for anvil to start
-sleep 5
 
 echo "Setting up local testnet"
 
@@ -41,28 +35,31 @@ exit_if_fails cp -R $HOME/.lighthouse/local-testnet/node_1 $HOME/.lighthouse/loc
 echo "Starting bootnode"
 
 exit_if_fails ../local_testnet/bootnode.sh &> /dev/null &
-BOOT_PID=$!
+
+exit_if_fails ../local_testnet/el_bootnode.sh &> /dev/null &
 
 # wait for the bootnode to start
 sleep 10
 
+echo "Starting local execution nodes"
+
+exit_if_fails ../local_testnet/geth.sh $HOME/.lighthouse/local-testnet/geth_datadir1 7000 6000 5000 $genesis_file &> geth.log &
+exit_if_fails ../local_testnet/geth.sh $HOME/.lighthouse/local-testnet/geth_datadir2 7100 6100 5100 $genesis_file &> /dev/null &
+exit_if_fails ../local_testnet/geth.sh $HOME/.lighthouse/local-testnet/geth_datadir3 7200 6200 5200 $genesis_file &> /dev/null &
+
+sleep 20
+
 echo "Starting local beacon nodes"
 
-exit_if_fails ../local_testnet/beacon_node.sh $HOME/.lighthouse/local-testnet/node_1 9000 8000 &> /dev/null &
-BEACON_PID=$!
-exit_if_fails ../local_testnet/beacon_node.sh $HOME/.lighthouse/local-testnet/node_2 9100 8100 &> /dev/null &
-BEACON_PID2=$!
-exit_if_fails ../local_testnet/beacon_node.sh $HOME/.lighthouse/local-testnet/node_3 9200 8200 &> /dev/null &
-BEACON_PID3=$!
+exit_if_fails ../local_testnet/beacon_node.sh -d debug $HOME/.lighthouse/local-testnet/node_1 9000 8000 http://localhost:5000 $HOME/.lighthouse/local-testnet/geth_datadir1/geth/jwtsecret &> beacon1.log &
+exit_if_fails ../local_testnet/beacon_node.sh $HOME/.lighthouse/local-testnet/node_2 9100 8100 http://localhost:5100 $HOME/.lighthouse/local-testnet/geth_datadir2/geth/jwtsecret &> /dev/null &
+exit_if_fails ../local_testnet/beacon_node.sh $HOME/.lighthouse/local-testnet/node_3 9200 8200 http://localhost:5200 $HOME/.lighthouse/local-testnet/geth_datadir3/geth/jwtsecret &> /dev/null &
 
 echo "Starting local validator clients"
 
 exit_if_fails ../local_testnet/validator_client.sh $HOME/.lighthouse/local-testnet/node_1 http://localhost:8000 &> /dev/null &
-VALIDATOR_1_PID=$!
 exit_if_fails ../local_testnet/validator_client.sh $HOME/.lighthouse/local-testnet/node_2 http://localhost:8100 &> /dev/null &
-VALIDATOR_2_PID=$!
 exit_if_fails ../local_testnet/validator_client.sh $HOME/.lighthouse/local-testnet/node_3 http://localhost:8200 &> /dev/null &
-VALIDATOR_3_PID=$!
 
 echo "Waiting an epoch before starting the next validator client"
 sleep $(( $SECONDS_PER_SLOT * 32 ))
@@ -71,15 +68,17 @@ if [[ "$BEHAVIOR" == "failure" ]]; then
 
     echo "Starting the doppelganger validator client"
 
-    # Use same keys as keys from VC1, but connect to BN2
+    # Use same keys as keys from VC1 and connect to BN2
     # This process should not last longer than 2 epochs
     timeout $(( $SECONDS_PER_SLOT * 32 * 2 )) ../local_testnet/validator_client.sh $HOME/.lighthouse/local-testnet/node_1_doppelganger http://localhost:8100
     DOPPELGANGER_EXIT=$?
 
     echo "Shutting down"
 
     # Cleanup
-    kill $BOOT_PID $BEACON_PID $BEACON_PID2 $BEACON_PID3 $ANVIL_PID $VALIDATOR_1_PID $VALIDATOR_2_PID $VALIDATOR_3_PID
+    killall geth
+    killall lighthouse
+    killall bootnode
 
     echo "Done"
 
@@ -98,7 +97,6 @@ if [[ "$BEHAVIOR" == "success" ]]; then
     echo "Starting the last validator client"
 
     ../local_testnet/validator_client.sh $HOME/.lighthouse/local-testnet/node_4 http://localhost:8100 &
-    VALIDATOR_4_PID=$!
     DOPPELGANGER_FAILURE=0
 
     # Sleep three epochs, then make sure all validators were active in epoch 2. Use
@@ -144,7 +142,10 @@ if [[ "$BEHAVIOR" == "success" ]]; then
 
     # Cleanup
     cd $PREVIOUS_DIR
-    kill $BOOT_PID $BEACON_PID $BEACON_PID2 $BEACON_PID3 $ANVIL_PID $VALIDATOR_1_PID $VALIDATOR_2_PID $VALIDATOR_3_PID $VALIDATOR_4_PID
+
+    killall geth
+    killall lighthouse
+    killall bootnode
 
     echo "Done"
 
@@ -153,4 +154,4 @@ if [[ "$BEHAVIOR" == "success" ]]; then
     fi
 fi
 
-exit 0
+exit 0
diff --git a/scripts/tests/genesis.json b/scripts/tests/genesis.json
