Move check status to list_validator

chong-he · chong-he · commit 24079658dbe6 · 2025-01-23T15:01:39.000+08:00
diff --git a/validator_manager/src/exit_validators.rs b/validator_manager/src/exit_validators.rs
@@ -19,7 +19,6 @@ pub const VC_TOKEN_FLAG: &str = "vc-token";
 pub const VALIDATOR_FLAG: &str = "validators";
 pub const EXIT_EPOCH_FLAG: &str = "exit-epoch";
 pub const PRESIGN_FLAG: &str = "presign";
-pub const EXIT_STATUS_FLAG: &str = "status";
 
 pub fn cli_app() -> Command {
     Command::new(CMD)
@@ -91,15 +90,6 @@ pub fn cli_app() -> Command {
                 .display_order(0)
                 .conflicts_with(BEACON_URL_FLAG),
         )
-        .arg(
-            Arg::new(EXIT_STATUS_FLAG)
-                .long(EXIT_STATUS_FLAG)
-                .help("Display the voluntary exit status.")
-                .help_heading(FLAG_HEADER)
-                .action(ArgAction::SetTrue)
-                .requires(BEACON_URL_FLAG)
-                .display_order(0),
-        )
 }
 
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
@@ -110,7 +100,6 @@ pub struct ExitConfig {
     pub beacon_url: Option<SensitiveUrl>,
     pub exit_epoch: Option<Epoch>,
     pub presign: bool,
-    pub exit_status: bool,
 }
 
 impl ExitConfig {
@@ -134,7 +123,6 @@ impl ExitConfig {
             beacon_url: clap_utils::parse_optional(matches, BEACON_URL_FLAG)?,
             exit_epoch: clap_utils::parse_optional(matches, EXIT_EPOCH_FLAG)?,
             presign: matches.get_flag(PRESIGN_FLAG),
-            exit_status: matches.get_flag(EXIT_STATUS_FLAG),
         })
     }
 }
@@ -160,7 +148,6 @@ async fn run<E: EthSpec>(config: ExitConfig) -> Result<(), String> {
         beacon_url,
         exit_epoch,
         presign,
-        exit_status,
     } = config;
 
     let (http_client, validators) = vc_http_client(vc_url.clone(), &vc_token_path).await?;
@@ -281,67 +268,13 @@ async fn run<E: EthSpec>(config: ExitConfig) -> Result<(), String> {
                     validator_to_exit
                 );
             }
-
-            // Check validator status after publishing voluntary exit
-            if exit_status {
-                let updated_validator_data = beacon_node
-                    .get_beacon_states_validator_id(
-                        StateId::Head,
-                        &ValidatorId::PublicKey(validator_to_exit),
-                    )
-                    .await
-                    .map_err(|e| format!("Failed to get updated validator details: {:?}", e))?
-                    .ok_or_else(|| {
-                        format!(
-                            "Validator {} is not present in the beacon state",
-                            validator_to_exit
-                        )
-                    })?
-                    .data;
-
-                if validator_data.status == ValidatorStatus::ActiveOngoing
-                    && updated_validator_data.status == ValidatorStatus::ActiveOngoing
-                {
-                    eprintln!("Voluntary exit for Validator {} is waiting to be accepted into the beacon chain.", validator_to_exit);
-                } else if updated_validator_data.status == ValidatorStatus::ActiveExiting {
-                    let exit_epoch = updated_validator_data.validator.exit_epoch;
-                    let withdrawal_epoch = updated_validator_data.validator.withdrawable_epoch;
-
-                    eprintln!("Voluntary exit for validator {} has been accepted into the beacon chain, but not yet finalized. \
-                        Finalization may take several minutes or longer. Before finalization there is a low \
-                        probability that the exit may be reverted.", validator_to_exit);
-                    eprintln!(
-                        "Current epoch: {}, Exit epoch: {}, Withdrawable epoch: {}",
-                        current_epoch, exit_epoch, withdrawal_epoch
-                    );
-                    eprintln!("Please keep your validator running till exit epoch");
-                    eprintln!(
-                        "Exit epoch in approximately {} secs",
-                        (exit_epoch - current_epoch) * spec.seconds_per_slot * E::slots_per_epoch()
-                    );
-                } else if updated_validator_data.status == ValidatorStatus::ExitedSlashed
-                    || updated_validator_data.status == ValidatorStatus::ExitedUnslashed
-                {
-                    {
-                        eprintln!(
-                            "Validator {} has exited at epoch: {}",
-                            validator_to_exit, updated_validator_data.validator.exit_epoch
-                        );
-                    }
-                } else {
-                    eprintln!(
-                        "Validator {} has not initiated voluntary exit. Validator status is: {}",
-                        validator_to_exit, updated_validator_data.status
-                    )
-                }
-            }
         }
     }
 
     Ok(())
 }
 
-fn get_current_epoch<E: EthSpec>(genesis_time: u64, spec: &ChainSpec) -> Option<Epoch> {
+pub fn get_current_epoch<E: EthSpec>(genesis_time: u64, spec: &ChainSpec) -> Option<Epoch> {
     let slot_clock = SystemTimeSlotClock::new(
         spec.genesis_slot,
         Duration::from_secs(genesis_time),
diff --git a/validator_manager/src/lib.rs b/validator_manager/src/lib.rs
@@ -91,7 +91,7 @@ pub fn run<E: EthSpec>(matches: &ArgMatches, env: Environment<E>) -> Result<(),
                         move_validators::cli_run(matches, dump_config).await
                     }
                     Some((list_validators::CMD, matches)) => {
-                        list_validators::cli_run(matches, dump_config).await
+                        list_validators::cli_run::<E>(matches, dump_config).await
                     }
                     Some((delete_validators::CMD, matches)) => {
                         delete_validators::cli_run(matches, dump_config).await
diff --git a/validator_manager/src/list_validators.rs b/validator_manager/src/list_validators.rs
@@ -1,14 +1,20 @@
 use clap::{Arg, ArgAction, ArgMatches, Command};
 use eth2::lighthouse_vc::types::SingleKeystoreResponse;
-use eth2::SensitiveUrl;
+use eth2::types::{ConfigAndPreset, StateId, ValidatorId, ValidatorStatus};
+use eth2::{BeaconNodeHttpClient, SensitiveUrl, Timeouts};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::time::Duration;
+use types::{ChainSpec, EthSpec, PublicKeyBytes};
 
+use crate::exit_validators::get_current_epoch;
 use crate::{common::vc_http_client, DumpConfig};
 
 pub const CMD: &str = "list";
 pub const VC_URL_FLAG: &str = "vc-url";
 pub const VC_TOKEN_FLAG: &str = "vc-token";
+pub const BEACON_URL_FLAG: &str = "beacon-node";
+pub const VALIDATOR_FLAG: &str = "validators";
 
 pub fn cli_app() -> Command {
     Command::new(CMD)
@@ -31,47 +37,177 @@ pub fn cli_app() -> Command {
                 .action(ArgAction::Set)
                 .display_order(0),
         )
+        .arg(
+            Arg::new(BEACON_URL_FLAG)
+                .long(BEACON_URL_FLAG)
+                .value_name("NETWORK_ADDRESS")
+                .help(
+                    "Address to a beacon node HTTP API. When supplied, \
+                    the status of validators (with regard to voluntary exit) \
+                    will be displayed. This flag is to be used together with \
+                    the --validators flag.",
+                )
+                .action(ArgAction::Set)
+                .display_order(0)
+                .requires(VALIDATOR_FLAG),
+        )
+        .arg(
+            Arg::new(VALIDATOR_FLAG)
+                .long(VALIDATOR_FLAG)
+                .value_name("STRING")
+                .help(
+                    "Comma-separated list of validators (pubkey) to display status for. \
+                 To display the status for all validators, use the keyword \"all\". \
+                 This flag is to be used together with the --beacon-node flag.",
+                )
+                .action(ArgAction::Set)
+                .display_order(0)
+                .requires(BEACON_URL_FLAG),
+        )
 }
 
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
 pub struct ListConfig {
     pub vc_url: SensitiveUrl,
     pub vc_token_path: PathBuf,
+    pub beacon_url: Option<SensitiveUrl>,
+    pub validators_to_display: Vec<PublicKeyBytes>,
 }
 
 impl ListConfig {
     fn from_cli(matches: &ArgMatches) -> Result<Self, String> {
+        let validators_to_display_str =
+            clap_utils::parse_optional::<String>(matches, VALIDATOR_FLAG)?;
+
+        // Keyword "all" to exit all validators, vector to be created later
+        let validators_to_display = match validators_to_display_str {
+            Some(str) => {
+                if str.trim() == "all" {
+                    Vec::new()
+                } else {
+                    str.split(',')
+                        .map(|s| s.trim().parse())
+                        .collect::<Result<Vec<PublicKeyBytes>, _>>()?
+                }
+            }
+            None => Vec::new(),
+        };
+
         Ok(Self {
             vc_token_path: clap_utils::parse_required(matches, VC_TOKEN_FLAG)?,
             vc_url: clap_utils::parse_required(matches, VC_URL_FLAG)?,
+            beacon_url: clap_utils::parse_optional(matches, BEACON_URL_FLAG)?,
+            validators_to_display,
         })
     }
 }
 
-pub async fn cli_run(matches: &ArgMatches, dump_config: DumpConfig) -> Result<(), String> {
+pub async fn cli_run<E: EthSpec>(
+    matches: &ArgMatches,
+    dump_config: DumpConfig,
+) -> Result<(), String> {
     let config = ListConfig::from_cli(matches)?;
     if dump_config.should_exit_early(&config)? {
         Ok(())
     } else {
-        run(config).await?;
+        run::<E>(config).await?;
         Ok(())
     }
 }
 
-async fn run(config: ListConfig) -> Result<Vec<SingleKeystoreResponse>, String> {
+async fn run<E: EthSpec>(config: ListConfig) -> Result<Vec<SingleKeystoreResponse>, String> {
     let ListConfig {
         vc_url,
         vc_token_path,
+        beacon_url,
+        mut validators_to_display,
     } = config;
 
     let (_, validators) = vc_http_client(vc_url.clone(), &vc_token_path).await?;
 
     println!("List of validators ({}):", validators.len());
 
-    for validator in &validators {
-        println!("{}", validator.validating_pubkey);
+    if validators_to_display.is_empty() {
+        validators_to_display = validators.iter().map(|v| v.validating_pubkey).collect();
     }
 
+    if let Some(ref beacon_url) = beacon_url {
+        for validator in &validators_to_display {
+            let beacon_node = BeaconNodeHttpClient::new(
+                SensitiveUrl::parse(beacon_url.as_ref())
+                    .map_err(|e| format!("Failed to parse beacon http server: {:?}", e))?,
+                Timeouts::set_all(Duration::from_secs(12)),
+            );
+
+            let validator_data = beacon_node
+                .get_beacon_states_validator_id(StateId::Head, &ValidatorId::PublicKey(*validator))
+                .await
+                .map_err(|e| format!("Failed to get updated validator details: {:?}", e))?
+                .ok_or_else(|| {
+                    format!("Validator {} is not present in the beacon state", validator)
+                })?
+                .data;
+
+            match validator_data.status {
+                ValidatorStatus::ActiveExiting => {
+                    let exit_epoch = validator_data.validator.exit_epoch;
+                    let withdrawal_epoch = validator_data.validator.withdrawable_epoch;
+
+                    let genesis_data = beacon_node
+                        .get_beacon_genesis()
+                        .await
+                        .map_err(|e| format!("Failed to get genesis data: {}", e))?
+                        .data;
+
+                    let config_and_preset = beacon_node
+                        .get_config_spec::<ConfigAndPreset>()
+                        .await
+                        .map_err(|e| format!("Failed to get config spec: {}", e))?
+                        .data;
+
+                    let spec = ChainSpec::from_config::<E>(config_and_preset.config())
+                        .ok_or("Failed to create chain spec")?;
+
+                    let current_epoch = get_current_epoch::<E>(genesis_data.genesis_time, &spec)
+                        .ok_or("Failed to get current epoch. Please check your system time")?;
+
+                    eprintln!(
+                        "Voluntary exit for validator {} has been accepted into the beacon chain. \
+                        Note that the voluntary exit is subject chain finalization. \
+                        Before the chain has finalized, there is a low \
+                        probability that the exit may be reverted.",
+                        validator
+                    );
+                    eprintln!(
+                        "Current epoch: {}, Exit epoch: {}, Withdrawable epoch: {}",
+                        current_epoch, exit_epoch, withdrawal_epoch
+                    );
+                    eprintln!("Please keep your validator running till exit epoch");
+                    eprintln!(
+                        "Exit epoch in approximately {} secs",
+                        (exit_epoch - current_epoch) * spec.seconds_per_slot * E::slots_per_epoch()
+                    );
+                }
+                ValidatorStatus::ExitedSlashed | ValidatorStatus::ExitedUnslashed => {
+                    eprintln!(
+                        "Validator {} has exited at epoch: {}",
+                        validator, validator_data.validator.exit_epoch
+                    );
+                }
+                _ => {
+                    eprintln!(
+                        "Validator {} has not initiated voluntary exit or the voluntary exit \
+                    is yet to be accepted into the beacon chain. Validator status is: {}",
+                        validator, validator_data.status
+                    )
+                }
+            }
+        }
+    } else {
+        for validator in &validators {
+            println!("{}", validator.validating_pubkey);
+        }
+    }
     Ok(validators)
 }
 

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ pub fn run<E: EthSpec>(matches: &ArgMatches, env: Environment<E>) -> Result<(),`
`91`	`91`	`move_validators::cli_run(matches, dump_config).await`
`92`	`92`	`}`
`93`	`93`	`Some((list_validators::CMD, matches)) => {`
`94`		`- list_validators::cli_run(matches, dump_config).await`
	`94`	`+ list_validators::cli_run::<E>(matches, dump_config).await`
`95`	`95`	`}`
`96`	`96`	`Some((delete_validators::CMD, matches)) => {`
`97`	`97`	`delete_validators::cli_run(matches, dump_config).await`