Add get-recent-prioritization-fees command to cli

cli/src/cli.rs

@@ -69,6 +69,10 @@ pub enum CliCommand {
     GetBlock {
         slot: Option<Slot>,
     },
+    GetRecentPrioritizationFees {
+        accounts: Vec<Pubkey>,
+        num_slots: Option<Slot>,
+    },
     GetBlockTime {
         slot: Option<Slot>,
     },
@@ -609,6 +613,9 @@ pub fn parse_command(
         }
         // Cluster Query Commands
         ("block", Some(matches)) => parse_get_block(matches),
+        ("recent-prioritization-fees", Some(matches)) => {
+            parse_get_recent_prioritization_fees(matches)
+        }
         ("block-height", Some(matches)) => parse_get_block_height(matches),
         ("block-production", Some(matches)) => parse_show_block_production(matches),
         ("block-time", Some(matches)) => parse_get_block_time(matches),
@@ -905,6 +912,10 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
         CliCommand::FirstAvailableBlock => process_first_available_block(&rpc_client),
         CliCommand::GetBlock { slot } => process_get_block(&rpc_client, config, *slot),
         CliCommand::GetBlockTime { slot } => process_get_block_time(&rpc_client, config, *slot),
+        CliCommand::GetRecentPrioritizationFees {
+            accounts,
+            num_slots,
+        } => process_get_recent_priority_fees(&rpc_client, config, accounts, *num_slots),
         CliCommand::GetEpoch => process_get_epoch(&rpc_client, config),
         CliCommand::GetEpochInfo => process_get_epoch_info(&rpc_client, config),
         CliCommand::GetGenesisHash => process_get_genesis_hash(&rpc_client),

cli/src/cluster_query.rs

@@ -102,6 +102,24 @@ impl ClusterQuerySubCommands for App<'_, '_> {
                         .index(1),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("recent-prioritization-fees")
+                .about("Get recent prioritization fees")
+                .arg(
+                    Arg::with_name("accounts")
+                        .long("accounts")
+                        .value_name("ACCOUNTS")
+                        .takes_value(true)
+                        .multiple(true)
+                        .index(1),
+                )
+                .arg(
+                    Arg::with_name("num_slots")
+                        .long("num-slots")
+                        .value_name("SLOTS")
+                        .takes_value(true),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("catchup")
                 .about("Wait for a validator to catch up to the cluster")
@@ -573,6 +591,19 @@ pub fn parse_get_block(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliEr
     }))
 }
 
+pub fn parse_get_recent_prioritization_fees(
+    matches: &ArgMatches<'_>,
+) -> Result<CliCommandInfo, CliError> {
+    let accounts = values_of(matches, "accounts").unwrap_or(vec![]);
+    let num_slots = value_of(matches, "num_slots");
+    Ok(CliCommandInfo::without_signers(
+        CliCommand::GetRecentPrioritizationFees {
+            accounts,
+            num_slots,
+        },
+    ))
+}
+
 pub fn parse_get_block_time(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let slot = value_of(matches, "slot");
     Ok(CliCommandInfo::without_signers(CliCommand::GetBlockTime {
@@ -1044,6 +1075,41 @@ pub fn process_leader_schedule(
     }))
 }
 
+pub fn process_get_recent_priority_fees(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    accounts: &[Pubkey],
+    num_slots: Option<Slot>,
+) -> ProcessResult {
+    let mut ret = String::new();
+    if let Ok(fees) = rpc_client.get_recent_prioritization_fees(accounts) {
+        let mut min = u64::MAX;
+        let mut max = 0;
+        let mut total = 0;
+        if config.verbose {
+            ret.push_str(&format!("{:<11} {}\n", "slot", "prioritization_fee"));
+        }
+        let num_slots = num_slots
+            .unwrap_or(fees.len() as u64)
+            .min(fees.len() as u64) as usize;
+        for fee in fees.iter().skip(fees.len() - num_slots).take(num_slots) {
+            min = min.min(fee.prioritization_fee);
+            max = max.max(fee.prioritization_fee);
+            total += fee.prioritization_fee;
+            if config.verbose {
+                ret.push_str(&format!("{:<11} {}\n", fee.slot, fee.prioritization_fee));
+            }
+        }
+        ret.push_str(&format!(
+            "Fees: Min: {} Max: {} Average: {:.2}",
+            min,
+            max,
+            total as f32 / fees.len() as f32
+        ));
+    }
+    Ok(ret)
+}
+
 pub fn process_get_block(
     rpc_client: &RpcClient,
     config: &CliConfig,