Delete uptime command, report total credits in solana validators instead

(cherry picked from commit 4c0420b884)

book/src/cli/usage.md

@@ -241,7 +241,6 @@ SUBCOMMANDS:
     stakes                              Show stake account information
     storage-account                     Show the contents of a storage account
     transaction-count                   Get current transaction count
-    uptime                              Show the uptime of a validator, based on epoch voting history
     validator-info                      Publish/get Validator info on Solana
     validators                          Show summary information about the current validators
     vote-account                        Show the contents of a vote account
@@ -1480,35 +1479,6 @@ OPTIONS:
     -k, --keypair <PATH>                    /path/to/id.json
 ```
 
-#### solana-uptime
-```text
-solana-uptime 
-Show the uptime of a validator, based on epoch voting history
-
-USAGE:
-    solana uptime [FLAGS] [OPTIONS] <VOTE ACCOUNT PUBKEY>
-
-FLAGS:
-        --aggregate                      Aggregate uptime data across span
-    -h, --help                           Prints help information
-        --skip-seed-phrase-validation    Skip validation of seed phrases. Use this if your phrase does not use the BIP39
-                                         official English word list
-    -V, --version                        Prints version information
-    -v, --verbose                        Show extra information header
-
-OPTIONS:
-        --ask-seed-phrase <KEYPAIR NAME>    Recover a keypair using a seed phrase and optional passphrase [possible
-                                            values: keypair]
-    -C, --config <PATH>                     Configuration file to use [default:
-                                            ~/.config/solana/cli/config.yml]
-    -u, --url <URL>                         JSON RPC URL for the solana cluster
-    -k, --keypair <PATH>                    /path/to/id.json
-        --span <NUM OF EPOCHS>              Number of recent epochs to examine
-
-ARGS:
-    <VOTE ACCOUNT PUBKEY>    Vote account pubkey
-```
-
 #### solana-validator-info
 ```text
 solana-validator-info

book/src/running-validator/validator-stake.md

@@ -83,7 +83,6 @@ To monitor your validator during its warmup period:
 
 * View your vote account:`solana vote-account ~/validator-vote-keypair.json` This displays the current state of all the votes the validator has submitted to the network.
 * View your stake account, the delegation preference and details of your stake:`solana stake-account ~/validator-stake-keypair.json`
-* `solana uptime ~/validator-vote-keypair.json` will display the voting history \(aka, uptime\) of your validator over recent Epochs
 * `solana validators` displays the current active stake of all validators, including yours
 * `solana stake-history ` shows the history of stake warming up and cooling down over recent epochs
 * Look for log messages on your validator indicating your next leader slot: `[2019-09-27T20:16:00.319721164Z INFO solana_core::replay_stage] <VALIDATOR_IDENTITY_PUBKEY> voted and reset PoH at tick height ####. My next leader slot is ####`

cli/src/cli.rs

@@ -343,11 +343,6 @@ pub enum CliCommand {
         pubkey: Pubkey,
         use_lamports_unit: bool,
     },
-    Uptime {
-        pubkey: Pubkey,
-        aggregate: bool,
-        span: Option<u64>,
-    },
     VoteAuthorize {
         vote_account_pubkey: Pubkey,
         new_authorized_pubkey: Pubkey,
@@ -539,7 +534,6 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
             parse_vote_authorize(matches, VoteAuthorize::Withdrawer)
         }
         ("vote-account", Some(matches)) => parse_vote_get_account_command(matches),
-        ("uptime", Some(matches)) => parse_vote_uptime_command(matches),
         // Wallet Commands
         ("address", Some(_matches)) => Ok(CliCommandInfo {
             command: CliCommand::Address,
@@ -1609,11 +1603,6 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
             &new_identity_pubkey,
             authorized_voter,
         ),
-        CliCommand::Uptime {
-            pubkey: vote_account_pubkey,
-            aggregate,
-            span,
-        } => process_uptime(&rpc_client, config, &vote_account_pubkey, *aggregate, *span),
 
         // Wallet Commands
 

cli/src/cluster_query.rs

@@ -14,7 +14,7 @@ use solana_sdk::{
     account_utils::StateMut,
     clock::{self, Slot},
     commitment_config::CommitmentConfig,
-    epoch_schedule::{Epoch, EpochSchedule},
+    epoch_schedule::Epoch,
     hash::Hash,
     pubkey::Pubkey,
     signature::{Keypair, KeypairUtil},
@@ -321,20 +321,6 @@ fn new_spinner_progress_bar() -> ProgressBar {
     progress_bar
 }
 
-/// Aggregate epoch credit stats and return (total credits, total slots, total epochs)
-pub fn aggregate_epoch_credits(
-    epoch_credits: &[(Epoch, u64, u64)],
-    epoch_schedule: &EpochSchedule,
-) -> (u64, u64, u64) {
-    epoch_credits
-        .iter()
-        .fold((0, 0, 0), |acc, (epoch, credits, prev_credits)| {
-            let credits_earned = credits - prev_credits;
-            let slots_in_epoch = epoch_schedule.get_slots_in_epoch(*epoch);
-            (acc.0 + credits_earned, acc.1 + slots_in_epoch, acc.2 + 1)
-        })
-}
-
 pub fn process_catchup(rpc_client: &RpcClient, node_pubkey: &Pubkey) -> ProcessResult {
     let cluster_nodes = rpc_client.get_cluster_nodes()?;
 
@@ -900,7 +886,7 @@ pub fn process_show_stakes(
 }
 
 pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool) -> ProcessResult {
-    let epoch_schedule = rpc_client.get_epoch_schedule()?;
+    let epoch_info = rpc_client.get_epoch_info()?;
     let vote_accounts = rpc_client.get_vote_accounts()?;
     let total_active_stake = vote_accounts
         .current
@@ -949,7 +935,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
             "Commission",
             "Last Vote",
             "Root Block",
-            "Uptime",
+            "Credits",
             "Active Stake",
         ))
         .bold()
@@ -957,7 +943,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
 
     fn print_vote_account(
         vote_account: RpcVoteAccountInfo,
-        epoch_schedule: &EpochSchedule,
+        current_epoch: Epoch,
         total_active_stake: f64,
         use_lamports_unit: bool,
         delinquent: bool,
@@ -970,17 +956,6 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
             }
         }
 
-        fn uptime(epoch_credits: Vec<(Epoch, u64, u64)>, epoch_schedule: &EpochSchedule) -> String {
-            let (total_credits, total_slots, _) =
-                aggregate_epoch_credits(&epoch_credits, &epoch_schedule);
-            if total_slots > 0 {
-                let total_uptime = 100_f64 * total_credits as f64 / total_slots as f64;
-                format!("{:.2}%", total_uptime)
-            } else {
-                "-".into()
-            }
-        }
-
         println!(
             "{} {:<44}  {:<44}  {:>9}%   {:>8}  {:>10}  {:>7}  {}",
             if delinquent {
@@ -993,7 +968,15 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
             vote_account.commission,
             non_zero_or_dash(vote_account.last_vote),
             non_zero_or_dash(vote_account.root_slot),
-            uptime(vote_account.epoch_credits, epoch_schedule),
+            vote_account
+                .epoch_credits
+                .iter()
+                .find_map(|(epoch, credits, _)| if *epoch == current_epoch {
+                    Some(*credits)
+                } else {
+                    None
+                })
+                .unwrap_or(0),
             if vote_account.activated_stake > 0 {
                 format!(
                     "{} ({:.2}%)",
@@ -1009,7 +992,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
     for vote_account in vote_accounts.current.into_iter() {
         print_vote_account(
             vote_account,
-            &epoch_schedule,
+            epoch_info.epoch,
             total_active_stake,
             use_lamports_unit,
             false,
@@ -1018,7 +1001,7 @@ pub fn process_show_validators(rpc_client: &RpcClient, use_lamports_unit: bool)
     for vote_account in vote_accounts.delinquent.into_iter() {
         print_vote_account(
             vote_account,
-            &epoch_schedule,
+            epoch_info.epoch,
             total_active_stake,
             use_lamports_unit,
             true,

cli/src/vote.rs

@@ -1,10 +1,6 @@
-use crate::{
+use crate::cli::{
-    cli::{
+    build_balance_message, check_account_for_fee, check_unique_pubkeys,
-        build_balance_message, check_account_for_fee, check_unique_pubkeys,
+    log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
-        log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError,
-        ProcessResult,
-    },
-    cluster_query::aggregate_epoch_credits,
 };
 use clap::{value_t_or_exit, App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{input_parsers::*, input_validators::*};
@@ -176,31 +172,6 @@ impl VoteSubCommands for App<'_, '_> {
                         .help("Display balance in lamports instead of SOL"),
                 ),
         )
-        .subcommand(
-            SubCommand::with_name("uptime")
-                .about("Show the uptime of a validator, based on epoch voting history")
-                .arg(
-                    Arg::with_name("vote_account_pubkey")
-                        .index(1)
-                        .value_name("VOTE ACCOUNT PUBKEY")
-                        .takes_value(true)
-                        .required(true)
-                        .validator(is_pubkey_or_keypair)
-                        .help("Vote account pubkey"),
-                )
-                .arg(
-                    Arg::with_name("span")
-                        .long("span")
-                        .value_name("NUM OF EPOCHS")
-                        .takes_value(true)
-                        .help("Number of recent epochs to examine"),
-                )
-                .arg(
-                    Arg::with_name("aggregate")
-                        .long("aggregate")
-                        .help("Aggregate uptime data across span"),
-                ),
-        )
     }
 }
 
@@ -271,24 +242,6 @@ pub fn parse_vote_get_account_command(
     })
 }
 
-pub fn parse_vote_uptime_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let vote_account_pubkey = pubkey_of(matches, "vote_account_pubkey").unwrap();
-    let aggregate = matches.is_present("aggregate");
-    let span = if matches.is_present("span") {
-        Some(value_t_or_exit!(matches, "span", u64))
-    } else {
-        None
-    };
-    Ok(CliCommandInfo {
-        command: CliCommand::Uptime {
-            pubkey: vote_account_pubkey,
-            aggregate,
-            span,
-        },
-        require_keypair: false,
-    })
-}
-
 pub fn process_create_vote_account(
     rpc_client: &RpcClient,
     config: &CliConfig,
@@ -517,60 +470,6 @@ pub fn process_show_vote_account(
     Ok("".to_string())
 }
 
-pub fn process_uptime(
-    rpc_client: &RpcClient,
-    _config: &CliConfig,
-    vote_account_pubkey: &Pubkey,
-    aggregate: bool,
-    span: Option<u64>,
-) -> ProcessResult {
-    let (_vote_account, vote_state) = get_vote_account(rpc_client, vote_account_pubkey)?;
-
-    let epoch_schedule = rpc_client.get_epoch_schedule()?;
-
-    println!("validator identity: {}", vote_state.node_pubkey);
-    println!("authorized voter: {}", vote_state.authorized_voter);
-    if !vote_state.votes.is_empty() {
-        println!("uptime:");
-
-        let epoch_credits: Vec<(u64, u64, u64)> = if let Some(x) = span {
-            vote_state
-                .epoch_credits()
-                .iter()
-                .rev()
-                .take(x as usize)
-                .cloned()
-                .collect()
-        } else {
-            vote_state.epoch_credits().iter().rev().cloned().collect()
-        };
-
-        if aggregate {
-            let (total_credits, total_slots, epochs) =
-                aggregate_epoch_credits(&epoch_credits, &epoch_schedule);
-            if total_slots > 0 {
-                let total_uptime = 100_f64 * total_credits as f64 / total_slots as f64;
-                println!("{:.2}% over {} epochs", total_uptime, epochs);
-            } else {
-                println!("Insufficient voting history available");
-            }
-        } else {
-            for (epoch, credits, prev_credits) in epoch_credits {
-                let credits_earned = credits - prev_credits;
-                let slots_in_epoch = epoch_schedule.get_slots_in_epoch(epoch);
-                let uptime = credits_earned as f64 / slots_in_epoch as f64;
-                println!("- epoch: {} {:.2}% uptime", epoch, uptime * 100_f64,);
-            }
-        }
-        if let Some(x) = span {
-            if x > vote_state.epoch_credits().len() as u64 {
-                println!("(span longer than available epochs)");
-            }
-        }
-    }
-    Ok("".to_string())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -741,27 +640,5 @@ mod tests {
                 require_keypair: true
             }
         );
-
-        // Test Uptime Subcommand
-        let pubkey = Pubkey::new_rand();
-        let matches = test_commands.clone().get_matches_from(vec![
-            "test",
-            "uptime",
-            &pubkey.to_string(),
-            "--span",
-            "4",
-            "--aggregate",
-        ]);
-        assert_eq!(
-            parse_command(&matches).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::Uptime {
-                    pubkey,
-                    aggregate: true,
-                    span: Some(4)
-                },
-                require_keypair: false
-            }
-        );
     }
 }