Validator manager commands for standard key-manager APIs

book/src/help_vm.md

@@ -23,6 +23,14 @@ Commands:
           "create-validators" command. This command only supports validators
           signing via a keystore on the local file system (i.e., not Web3Signer
           validators).
+  list
+          Lists all validators in a validator client using the HTTP API.
+  delete
+          Deletes validator from a validator client using the HTTP API.
+  import-standard
+          Uploads validators to a validator client using the HTTP API. The
+          validators are defined in a JSON file which can be generated using the
+          staking deposit CLI.
   help
           Print this message or the help of the given subcommand(s)
 

common/account_utils/src/lib.rs

@@ -9,13 +9,16 @@ use eth2_wallet::{
 use filesystem::{create_with_600_perms, Error as FsError};
 use rand::{distributions::Alphanumeric, Rng};
 use serde::{Deserialize, Serialize};
-use std::fs::{self, File};
 use std::io;
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 use std::str::from_utf8;
 use std::thread::sleep;
 use std::time::Duration;
+use std::{
+    fs::{self, File},
+    str::FromStr,
+};
 use zeroize::Zeroize;
 
 pub mod validator_definitions;
@@ -213,6 +216,14 @@ pub fn mnemonic_from_phrase(phrase: &str) -> Result<Mnemonic, String> {
 #[serde(transparent)]
 pub struct ZeroizeString(String);
 
+impl FromStr for ZeroizeString {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(s.to_owned()))
+    }
+}
+
 impl From<String> for ZeroizeString {
     fn from(s: String) -> Self {
         Self(s)

validator_client/src/http_api/keystores.rs

@@ -238,7 +238,14 @@ pub fn delete<T: SlotClock + 'static, E: EthSpec>(
     task_executor: TaskExecutor,
     log: Logger,
 ) -> Result<DeleteKeystoresResponse, Rejection> {
-    let export_response = export(request, validator_store, task_executor, log)?;
+    let export_response = export(request, validator_store, task_executor, log.clone())?;
+
+    info!(
+        log,
+        "Deleting keystores via standard HTTP API";
+        "count" => export_response.data.len(),
+    );
+
     Ok(DeleteKeystoresResponse {
         data: export_response
             .data

validator_manager/src/create_validators.rs

@@ -45,15 +45,6 @@ pub fn cli_app() -> Command {
                 Another, optional JSON file is created which contains a list of validator \
                 deposits in the same format as the \"ethereum/staking-deposit-cli\" tool.",
         )
-        .arg(
-            Arg::new("help")
-                .long("help")
-                .short('h')
-                .help("Prints help information")
-                .action(ArgAction::HelpLong)
-                .display_order(0)
-                .help_heading(FLAG_HEADER),
-        )
         .arg(
             Arg::new(OUTPUT_PATH_FLAG)
                 .long(OUTPUT_PATH_FLAG)

validator_manager/src/delete_validator.rs

@@ -0,0 +1,263 @@
+use std::path::PathBuf;
+
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use eth2::{
+    lighthouse_vc::types::{DeleteKeystoreStatus, DeleteKeystoresRequest},
+    SensitiveUrl,
+};
+use serde::{Deserialize, Serialize};
+use types::PublicKeyBytes;
+
+use crate::{common::vc_http_client, DumpConfig};
+
+pub const CMD: &str = "delete";
+pub const VC_URL_FLAG: &str = "vc-url";
+pub const VC_TOKEN_FLAG: &str = "vc-token";
+pub const VALIDATOR_FLAG: &str = "validator";
+
+#[derive(Debug)]
+pub enum DeleteError {
+    InvalidPublicKey,
+    DeleteFailed(eth2::Error),
+}
+
+pub fn cli_app() -> Command {
+    Command::new(CMD)
+        .about("Deletes validator from a validator client using the HTTP API.")
+        .arg(
+            Arg::new(VC_URL_FLAG)
+                .long(VC_URL_FLAG)
+                .value_name("HTTP_ADDRESS")
+                .help(
+                    "A HTTP(S) address of a validator client using the keymanager-API. \
+            If this value is not supplied then a 'dry run' will be conducted where \
+            no changes are made to the validator client.",
+                )
+                .default_value("http://localhost:5062")
+                .requires(VC_TOKEN_FLAG)
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(VC_TOKEN_FLAG)
+                .long(VC_TOKEN_FLAG)
+                .value_name("PATH")
+                .help("The file containing a token required by the validator client.")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(VALIDATOR_FLAG)
+                .long(VALIDATOR_FLAG)
+                .value_name("STRING")
+                .help("Validator that will be deleted (pubkey).")
+                .action(ArgAction::Set),
+        )
+}
+
+#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
+pub struct DeleteConfig {
+    pub vc_url: SensitiveUrl,
+    pub vc_token_path: PathBuf,
+    pub validator_to_delete: PublicKeyBytes,
+}
+
+impl DeleteConfig {
+    fn from_cli(matches: &ArgMatches) -> Result<Self, String> {
+        Ok(Self {
+            vc_token_path: clap_utils::parse_required(matches, VC_TOKEN_FLAG)?,
+            validator_to_delete: clap_utils::parse_required(matches, VALIDATOR_FLAG)?,
+            vc_url: clap_utils::parse_required(matches, VC_URL_FLAG)?,
+        })
+    }
+}
+
+pub async fn cli_run(matches: &ArgMatches, dump_config: DumpConfig) -> Result<(), String> {
+    let config = DeleteConfig::from_cli(matches)?;
+    if dump_config.should_exit_early(&config)? {
+        Ok(())
+    } else {
+        run(config).await
+    }
+}
+
+pub async fn run<'a>(config: DeleteConfig) -> Result<(), String> {
+    let DeleteConfig {
+        vc_url,
+        vc_token_path,
+        validator_to_delete,
+    } = config;
+
+    let (http_client, _keystores) = vc_http_client(vc_url.clone(), &vc_token_path).await?;
+
+    let validators = http_client.get_keystores().await.unwrap().data;
+
+    if !validators
+        .iter()
+        .any(|validator| validator.validating_pubkey == validator_to_delete)
+    {
+        return Err(format!("Validator {} doesn't exists", validator_to_delete));
+    }
+
+    let delete_request = DeleteKeystoresRequest {
+        pubkeys: vec![validator_to_delete],
+    };
+
+    let response = http_client
+        .delete_keystores(&delete_request)
+        .await
+        .map_err(|e| format!("Error deleting keystore {}", e))?
+        .data;
+
+    if response[0].status == DeleteKeystoreStatus::Error
+        || response[0].status == DeleteKeystoreStatus::NotFound
+        || response[0].status == DeleteKeystoreStatus::NotActive
+    {
+        eprintln!("Problem with removing validator {}", validator_to_delete);
+        return Err(format!(
+            "Problem with removing validator {}",
+            validator_to_delete
+        ));
+    }
+
+    eprintln!("Validator deleted");
+    Ok(())
+}
+
+#[cfg(not(debug_assertions))]
+#[cfg(test)]
+mod test {
+    use std::{
+        fs::{self, File},
+        io::Write,
+        str::FromStr,
+    };
+
+    use super::*;
+    use crate::{
+        common::ValidatorSpecification, import_validators::tests::TestBuilder as ImportTestBuilder,
+    };
+    use validator_client::http_api::{test_utils::ApiTester, Config as HttpConfig};
+
+    struct TestBuilder {
+        delete_config: Option<DeleteConfig>,
+        src_import_builder: Option<ImportTestBuilder>,
+        http_config: HttpConfig,
+        vc_token: Option<String>,
+        validators: Vec<ValidatorSpecification>,
+    }
+
+    impl TestBuilder {
+        async fn new() -> Self {
+            Self {
+                delete_config: None,
+                src_import_builder: None,
+                http_config: ApiTester::default_http_config(),
+                vc_token: None,
+                validators: vec![],
+            }
+        }
+
+        async fn with_validators(
+            mut self,
+            count: u32,
+            first_index: u32,
+            index_of_validator_to_delete: usize,
+        ) -> Self {
+            let builder = ImportTestBuilder::new_with_http_config(self.http_config.clone())
+                .await
+                .create_validators(count, first_index)
+                .await;
+
+            self.vc_token =
+                Some(fs::read_to_string(builder.get_import_config().vc_token_path).unwrap());
+
+            let local_validators: Vec<ValidatorSpecification> = {
+                let contents =
+                    fs::read_to_string(builder.get_import_config().validators_file_path).unwrap();
+                serde_json::from_str(&contents).unwrap()
+            };
+
+            let import_config = builder.get_import_config();
+
+            self.delete_config = Some(DeleteConfig {
+                vc_url: import_config.vc_url,
+                vc_token_path: import_config.vc_token_path,
+                validator_to_delete: PublicKeyBytes::from_str(
+                    format!(
+                        "0x{}",
+                        local_validators[index_of_validator_to_delete]
+                            .voting_keystore
+                            .pubkey()
+                    )
+                    .as_str(),
+                )
+                .unwrap(),
+            });
+
+            self.validators = local_validators.clone();
+            self.src_import_builder = Some(builder);
+            self
+        }
+
+        pub async fn run_test(self) -> TestResult {
+            let import_builder = self.src_import_builder.unwrap();
+            let import_test_result = import_builder.run_test().await;
+            assert!(import_test_result.result.is_ok());
+
+            let path = self.delete_config.clone().unwrap().vc_token_path;
+            let url = self.delete_config.clone().unwrap().vc_url;
+            let parent = path.parent().unwrap();
+
+            fs::create_dir_all(parent).expect("Was not able to create parent directory");
+
+            File::options()
+                .write(true)
+                .read(true)
+                .create(true)
+                .truncate(true)
+                .open(path.clone())
+                .unwrap()
+                .write_all(self.vc_token.clone().unwrap().as_bytes())
+                .unwrap();
+
+            let result = run(self.delete_config.clone().unwrap()).await;
+
+            if result.is_ok() {
+                let (http_client, _keystores) = vc_http_client(url, path.clone()).await.unwrap();
+                let list_keystores_response = http_client.get_keystores().await.unwrap().data;
+
+                assert_eq!(list_keystores_response.len(), self.validators.len() - 1);
+                assert!(list_keystores_response
+                    .iter()
+                    .all(|keystore| keystore.validating_pubkey
+                        != self.delete_config.clone().unwrap().validator_to_delete));
+
+                return TestResult { result: Ok(()) };
+            }
+
+            TestResult {
+                result: Err(result.unwrap_err()),
+            }
+        }
+    }
+
+    #[must_use]
+    struct TestResult {
+        result: Result<(), String>,
+    }
+
+    impl TestResult {
+        fn assert_ok(self) {
+            assert_eq!(self.result, Ok(()))
+        }
+    }
+    #[tokio::test]
+    async fn list_all_validators() {
+        TestBuilder::new()
+            .await
+            .with_validators(3, 0, 0)
+            .await
+            .run_test()
+            .await
+            .assert_ok();
+    }
+}