merge with unstable

common/deposit_contract/Cargo.toml

@@ -9,7 +9,7 @@ build = "build.rs"
 [build-dependencies]
 reqwest = { version = "0.11.0", features = ["blocking", "json", "native-tls-vendored"] }
 serde_json = "1.0.58"
-sha2 = "0.9.1"
+sha2 = "0.10"
 hex = "0.4.2"
 
 [dependencies]

common/eth2/src/lib.rs

@@ -114,6 +114,7 @@ pub struct Timeouts {
     pub sync_duties: Duration,
     pub get_beacon_blocks_ssz: Duration,
     pub get_debug_beacon_states: Duration,
+    pub get_deposit_snapshot: Duration,
 }
 
 impl Timeouts {
@@ -128,6 +129,7 @@ impl Timeouts {
             sync_duties: timeout,
             get_beacon_blocks_ssz: timeout,
             get_debug_beacon_states: timeout,
+            get_deposit_snapshot: timeout,
         }
     }
 }
@@ -934,6 +936,20 @@ impl BeaconNodeHttpClient {
         Ok(())
     }
 
+    /// `GET beacon/deposit_snapshot`
+    pub async fn get_deposit_snapshot(&self) -> Result<Option<types::DepositTreeSnapshot>, Error> {
+        use ssz::Decode;
+        let mut path = self.eth_path(V1)?;
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("deposit_snapshot");
+        self.get_bytes_opt_accept_header(path, Accept::Ssz, self.timeouts.get_deposit_snapshot)
+            .await?
+            .map(|bytes| DepositTreeSnapshot::from_ssz_bytes(&bytes).map_err(Error::InvalidSsz))
+            .transpose()
+    }
+
     /// `POST validator/contribution_and_proofs`
     pub async fn post_validator_contribution_and_proofs<T: EthSpec>(
         &self,

common/eth2/src/lighthouse.rs

@@ -6,7 +6,10 @@ mod block_rewards;
 
 use crate::{
     ok_or_error,
-    types::{BeaconState, ChainSpec, Epoch, EthSpec, GenericResponse, ValidatorId},
+    types::{
+        BeaconState, ChainSpec, DepositTreeSnapshot, Epoch, EthSpec, FinalizedExecutionBlock,
+        GenericResponse, ValidatorId,
+    },
     BeaconNodeHttpClient, DepositData, Error, Eth1Data, Hash256, StateId, StatusCode,
 };
 use proto_array::core::ProtoArray;
@@ -331,6 +334,19 @@ impl Eth1Block {
     }
 }
 
+impl From<Eth1Block> for FinalizedExecutionBlock {
+    fn from(eth1_block: Eth1Block) -> Self {
+        Self {
+            deposit_count: eth1_block.deposit_count.unwrap_or(0),
+            deposit_root: eth1_block
+                .deposit_root
+                .unwrap_or_else(|| DepositTreeSnapshot::default().deposit_root),
+            block_hash: eth1_block.hash,
+            block_height: eth1_block.number,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct DatabaseInfo {
     pub schema_version: u64,

common/eth2_network_config/Cargo.toml

@@ -18,4 +18,4 @@ serde_yaml = "0.8.13"
 types = { path = "../../consensus/types"}
 eth2_ssz = "0.4.1"
 eth2_config = { path = "../eth2_config"}
-enr = { version = "0.5.1", features = ["ed25519", "k256"] }
+enr = { version = "0.6.2", features = ["ed25519", "k256"] }

common/fallback/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "fallback"
-version = "0.1.0"
-authors = ["blacktemplar <blacktemplar@a1.net>"]
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-itertools = "0.10.0"

common/fallback/src/lib.rs

@@ -1,63 +0,0 @@
-use itertools::{join, zip};
-use std::fmt::{Debug, Display};
-use std::future::Future;
-
-#[derive(Clone)]
-pub struct Fallback<T> {
-    pub servers: Vec<T>,
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FallbackError<E> {
-    AllErrored(Vec<E>),
-}
-
-impl<T> Fallback<T> {
-    pub fn new(servers: Vec<T>) -> Self {
-        Self { servers }
-    }
-
-    /// Return the first successful result along with number of previous errors encountered
-    /// or all the errors encountered if every server fails.
-    pub async fn first_success<'a, F, O, E, R>(
-        &'a self,
-        func: F,
-    ) -> Result<(O, usize), FallbackError<E>>
-    where
-        F: Fn(&'a T) -> R,
-        R: Future<Output = Result<O, E>>,
-    {
-        let mut errors = vec![];
-        for server in &self.servers {
-            match func(server).await {
-                Ok(val) => return Ok((val, errors.len())),
-                Err(e) => errors.push(e),
-            }
-        }
-        Err(FallbackError::AllErrored(errors))
-    }
-
-    pub fn map_format_error<'a, E, F, S>(&'a self, f: F, error: &FallbackError<E>) -> String
-    where
-        F: FnMut(&'a T) -> &'a S,
-        S: Display + 'a,
-        E: Debug,
-    {
-        match error {
-            FallbackError::AllErrored(v) => format!(
-                "All fallbacks errored: {}",
-                join(
-                    zip(self.servers.iter().map(f), v.iter())
-                        .map(|(server, error)| format!("{} => {:?}", server, error)),
-                    ", "
-                )
-            ),
-        }
-    }
-}
-
-impl<T: Display> Fallback<T> {
-    pub fn format_error<E: Debug>(&self, error: &FallbackError<E>) -> String {
-        self.map_format_error(|s| s, error)
-    }
-}

common/lighthouse_version/src/lib.rs

@@ -17,8 +17,8 @@ pub const VERSION: &str = git_version!(
         // NOTE: using --match instead of --exclude for compatibility with old Git
         "--match=thiswillnevermatchlol"
     ],
-    prefix = "Lighthouse/v3.1.2-",
-    fallback = "Lighthouse/v3.1.2"
+    prefix = "Lighthouse/v3.2.1-",
+    fallback = "Lighthouse/v3.2.1"
 );
 
 /// Returns `VERSION`, but with platform information appended to the end.

common/monitoring_api/src/gather.rs

@@ -43,6 +43,16 @@ impl JsonMetric {
             }
         }
     }
+
+    /// Return a default json value given given the metric type.
+    fn get_typed_value_default(&self) -> serde_json::Value {
+        match self.ty {
+            JsonType::Integer => json!(0),
+            JsonType::Boolean => {
+                json!(false)
+            }
+        }
+    }
 }
 
 /// The required metrics for the beacon and validator processes.
@@ -155,6 +165,16 @@ pub fn gather_metrics(metrics_map: &HashMap<String, JsonMetric>) -> Option<serde
             let _ = res.insert(metric.json_output_key.to_string(), value);
         };
     }
+    // Insert default metrics for all monitoring service metrics that do not
+    // exist as lighthouse metrics.
+    for json_metric in metrics_map.values() {
+        if !res.contains_key(json_metric.json_output_key) {
+            let _ = res.insert(
+                json_metric.json_output_key.to_string(),
+                json_metric.get_typed_value_default(),
+            );
+        }
+    }
     Some(serde_json::Value::Object(res))
 }