Merge branch 'unstable' into off-4844

beacon_node/http_api/src/lib.rs

@@ -2374,11 +2374,19 @@ pub fn serve<T: BeaconChainTypes>(
         .and(not_while_syncing_filter.clone())
         .and(warp::query::<api_types::ValidatorBlocksQuery>())
         .and(chain_filter.clone())
+        .and(log_filter.clone())
         .and_then(
             |endpoint_version: EndpointVersion,
              slot: Slot,
              query: api_types::ValidatorBlocksQuery,
-             chain: Arc<BeaconChain<T>>| async move {
+             chain: Arc<BeaconChain<T>>,
+             log: Logger| async move {
+                debug!(
+                    log,
+                    "Block production request from HTTP API";
+                    "slot" => slot
+                );
+
                 let randao_reveal = query.randao_reveal.decompress().map_err(|e| {
                     warp_utils::reject::custom_bad_request(format!(
                         "randao reveal is not a valid BLS signature: {:?}",
@@ -3125,6 +3133,22 @@ pub fn serve<T: BeaconChainTypes>(
             },
         );
 
+    // POST lighthouse/ui/validator_info
+    let post_lighthouse_ui_validator_info = warp::path("lighthouse")
+        .and(warp::path("ui"))
+        .and(warp::path("validator_info"))
+        .and(warp::path::end())
+        .and(warp::body::json())
+        .and(chain_filter.clone())
+        .and_then(
+            |request_data: ui::ValidatorInfoRequestData, chain: Arc<BeaconChain<T>>| {
+                blocking_json_task(move || {
+                    ui::get_validator_info(request_data, chain)
+                        .map(api_types::GenericResponse::from)
+                })
+            },
+        );
+
     // GET lighthouse/syncing
     let get_lighthouse_syncing = warp::path("lighthouse")
         .and(warp::path("syncing"))
@@ -3660,6 +3684,7 @@ pub fn serve<T: BeaconChainTypes>(
                 .or(post_lighthouse_database_historical_blocks.boxed())
                 .or(post_lighthouse_block_rewards.boxed())
                 .or(post_lighthouse_ui_validator_metrics.boxed())
+                .or(post_lighthouse_ui_validator_info.boxed())
                 .recover(warp_utils::reject::handle_rejection),
         ))
         .recover(warp_utils::reject::handle_rejection)

beacon_node/http_api/src/publish_blocks.rs

@@ -5,7 +5,7 @@ use beacon_chain::NotifyExecutionLayer;
 use beacon_chain::{BeaconChain, BeaconChainTypes, BlockError, CountUnrealized};
 use lighthouse_network::PubsubMessage;
 use network::NetworkMessage;
-use slog::{error, info, warn, Logger};
+use slog::{debug, error, info, warn, Logger};
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use tokio::sync::mpsc::UnboundedSender;
@@ -29,6 +29,11 @@ pub async fn publish_block<T: BeaconChainTypes>(
     //FIXME(sean) have to move this to prior to publishing because it's included in the blobs sidecar message.
     //this may skew metrics
     let block_root = block_root.unwrap_or_else(|| block.canonical_root());
+    debug!(
+        log,
+        "Signed block published to HTTP API";
+        "slot" => block.slot()
+    );
 
     // Send the block, regardless of whether or not it is valid. The API
     // specification is very clear that this is the desired behaviour.

beacon_node/http_api/src/ui.rs

@@ -1,5 +1,7 @@
-use beacon_chain::{metrics, BeaconChain, BeaconChainError, BeaconChainTypes};
-use eth2::types::ValidatorStatus;
+use beacon_chain::{
+    validator_monitor::HISTORIC_EPOCHS, BeaconChain, BeaconChainError, BeaconChainTypes,
+};
+use eth2::types::{Epoch, ValidatorStatus};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
@@ -71,6 +73,82 @@ pub fn get_validator_count<T: BeaconChainTypes>(
     })
 }
 
+#[derive(PartialEq, Serialize, Deserialize)]
+pub struct ValidatorInfoRequestData {
+    #[serde(with = "eth2_serde_utils::quoted_u64_vec")]
+    indices: Vec<u64>,
+}
+
+#[derive(PartialEq, Serialize, Deserialize)]
+pub struct ValidatorInfoValues {
+    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    epoch: u64,
+    #[serde(with = "eth2_serde_utils::quoted_u64")]
+    total_balance: u64,
+}
+
+#[derive(PartialEq, Serialize, Deserialize)]
+pub struct ValidatorInfo {
+    info: Vec<ValidatorInfoValues>,
+}
+
+#[derive(PartialEq, Serialize, Deserialize)]
+pub struct ValidatorInfoResponse {
+    validators: HashMap<String, ValidatorInfo>,
+}
+
+pub fn get_validator_info<T: BeaconChainTypes>(
+    request_data: ValidatorInfoRequestData,
+    chain: Arc<BeaconChain<T>>,
+) -> Result<ValidatorInfoResponse, warp::Rejection> {
+    let current_epoch = chain.epoch().map_err(beacon_chain_error)?;
+
+    let epochs = current_epoch.saturating_sub(HISTORIC_EPOCHS).as_u64()..=current_epoch.as_u64();
+
+    let validator_ids = chain
+        .validator_monitor
+        .read()
+        .get_all_monitored_validators()
+        .iter()
+        .cloned()
+        .collect::<HashSet<String>>();
+
+    let indices = request_data
+        .indices
+        .iter()
+        .map(|index| index.to_string())
+        .collect::<HashSet<String>>();
+
+    let ids = validator_ids
+        .intersection(&indices)
+        .collect::<HashSet<&String>>();
+
+    let mut validators = HashMap::new();
+
+    for id in ids {
+        if let Ok(index) = id.parse::<u64>() {
+            if let Some(validator) = chain
+                .validator_monitor
+                .read()
+                .get_monitored_validator(index)
+            {
+                let mut info = vec![];
+                for epoch in epochs.clone() {
+                    if let Some(total_balance) = validator.get_total_balance(Epoch::new(epoch)) {
+                        info.push(ValidatorInfoValues {
+                            epoch,
+                            total_balance,
+                        });
+                    }
+                }
+                validators.insert(id.clone(), ValidatorInfo { info });
+            }
+        }
+    }
+
+    Ok(ValidatorInfoResponse { validators })
+}
+
 #[derive(PartialEq, Serialize, Deserialize)]
 pub struct ValidatorMetricsRequestData {
     indices: Vec<u64>,
@@ -119,76 +197,56 @@ pub fn post_validator_monitor_metrics<T: BeaconChainTypes>(
     let mut validators = HashMap::new();
 
     for id in ids {
-        let attestation_hits = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_ATTESTER_HIT,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let attestation_misses = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_ATTESTER_MISS,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let attestations = attestation_hits + attestation_misses;
-        let attestation_hit_percentage: f64 = if attestations == 0 {
-            0.0
-        } else {
-            (100 * attestation_hits / attestations) as f64
-        };
+        if let Ok(index) = id.parse::<u64>() {
+            if let Some(validator) = chain
+                .validator_monitor
+                .read()
+                .get_monitored_validator(index)
+            {
+                let val_metrics = validator.metrics.read();
+                let attestation_hits = val_metrics.attestation_hits;
+                let attestation_misses = val_metrics.attestation_misses;
+                let attestation_head_hits = val_metrics.attestation_head_hits;
+                let attestation_head_misses = val_metrics.attestation_head_misses;
+                let attestation_target_hits = val_metrics.attestation_target_hits;
+                let attestation_target_misses = val_metrics.attestation_target_misses;
+                drop(val_metrics);
 
-        let attestation_head_hits = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_HEAD_ATTESTER_HIT,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let attestation_head_misses = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_HEAD_ATTESTER_MISS,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let head_attestations = attestation_head_hits + attestation_head_misses;
-        let attestation_head_hit_percentage: f64 = if head_attestations == 0 {
-            0.0
-        } else {
-            (100 * attestation_head_hits / head_attestations) as f64
-        };
+                let attestations = attestation_hits + attestation_misses;
+                let attestation_hit_percentage: f64 = if attestations == 0 {
+                    0.0
+                } else {
+                    (100 * attestation_hits / attestations) as f64
+                };
+                let head_attestations = attestation_head_hits + attestation_head_misses;
+                let attestation_head_hit_percentage: f64 = if head_attestations == 0 {
+                    0.0
+                } else {
+                    (100 * attestation_head_hits / head_attestations) as f64
+                };
 
-        let attestation_target_hits = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_TARGET_ATTESTER_HIT,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let attestation_target_misses = metrics::get_int_counter(
-            &metrics::VALIDATOR_MONITOR_PREV_EPOCH_ON_CHAIN_TARGET_ATTESTER_MISS,
-            &[id],
-        )
-        .map(|counter| counter.get())
-        .unwrap_or(0);
-        let target_attestations = attestation_target_hits + attestation_target_misses;
-        let attestation_target_hit_percentage: f64 = if target_attestations == 0 {
-            0.0
-        } else {
-            (100 * attestation_target_hits / target_attestations) as f64
-        };
+                let target_attestations = attestation_target_hits + attestation_target_misses;
+                let attestation_target_hit_percentage: f64 = if target_attestations == 0 {
+                    0.0
+                } else {
+                    (100 * attestation_target_hits / target_attestations) as f64
+                };
 
-        let metrics = ValidatorMetrics {
-            attestation_hits,
-            attestation_misses,
-            attestation_hit_percentage,
-            attestation_head_hits,
-            attestation_head_misses,
-            attestation_head_hit_percentage,
-            attestation_target_hits,
-            attestation_target_misses,
-            attestation_target_hit_percentage,
-        };
+                let metrics = ValidatorMetrics {
+                    attestation_hits,
+                    attestation_misses,
+                    attestation_hit_percentage,
+                    attestation_head_hits,
+                    attestation_head_misses,
+                    attestation_head_hit_percentage,
+                    attestation_target_hits,
+                    attestation_target_misses,
+                    attestation_target_hit_percentage,
+                };
 
-        validators.insert(id.clone(), metrics);
+                validators.insert(id.clone(), metrics);
+            }
+        }
     }
 
     Ok(ValidatorMetricsResponse { validators })