merge with unstable

beacon_node/http_api/src/lib.rs

@@ -1535,6 +1535,53 @@ pub fn serve<T: BeaconChainTypes>(
             },
         );
 
+    // GET beacon/deposit_snapshot
+    let get_beacon_deposit_snapshot = eth_v1
+        .and(warp::path("beacon"))
+        .and(warp::path("deposit_snapshot"))
+        .and(warp::path::end())
+        .and(warp::header::optional::<api_types::Accept>("accept"))
+        .and(eth1_service_filter.clone())
+        .and_then(
+            |accept_header: Option<api_types::Accept>, eth1_service: eth1::Service| {
+                blocking_task(move || match accept_header {
+                    Some(api_types::Accept::Json) | None => {
+                        let snapshot = eth1_service.get_deposit_snapshot();
+                        Ok(
+                            warp::reply::json(&api_types::GenericResponse::from(snapshot))
+                                .into_response(),
+                        )
+                    }
+                    _ => eth1_service
+                        .get_deposit_snapshot()
+                        .map(|snapshot| {
+                            Response::builder()
+                                .status(200)
+                                .header("Content-Type", "application/octet-stream")
+                                .body(snapshot.as_ssz_bytes().into())
+                                .map_err(|e| {
+                                    warp_utils::reject::custom_server_error(format!(
+                                        "failed to create response: {}",
+                                        e
+                                    ))
+                                })
+                        })
+                        .unwrap_or_else(|| {
+                            Response::builder()
+                                .status(503)
+                                .header("Content-Type", "application/octet-stream")
+                                .body(Vec::new().into())
+                                .map_err(|e| {
+                                    warp_utils::reject::custom_server_error(format!(
+                                        "failed to create response: {}",
+                                        e
+                                    ))
+                                })
+                        }),
+                })
+            },
+        );
+
     /*
      * config
      */
@@ -3122,6 +3169,7 @@ pub fn serve<T: BeaconChainTypes>(
                 .or(get_beacon_pool_attester_slashings.boxed())
                 .or(get_beacon_pool_proposer_slashings.boxed())
                 .or(get_beacon_pool_voluntary_exits.boxed())
+                .or(get_beacon_deposit_snapshot.boxed())
                 .or(get_config_fork_schedule.boxed())
                 .or(get_config_spec.boxed())
                 .or(get_config_deposit_contract.boxed())

beacon_node/http_api/src/state_id.rs

@@ -155,33 +155,12 @@ impl StateId {
         Ok((state, execution_optimistic))
     }
 
-    /*
     /// Map a function across the `BeaconState` identified by `self`.
     ///
+    /// The optimistic status of the requested state is also provided to the `func` closure.
+    ///
     /// This function will avoid instantiating/copying a new state when `self` points to the head
     /// of the chain.
-    #[allow(dead_code)]
-    pub fn map_state<T: BeaconChainTypes, F, U>(
-        &self,
-        chain: &BeaconChain<T>,
-        func: F,
-    ) -> Result<U, warp::Rejection>
-    where
-        F: Fn(&BeaconState<T::EthSpec>) -> Result<U, warp::Rejection>,
-    {
-        match &self.0 {
-            CoreStateId::Head => chain
-                .with_head(|snapshot| Ok(func(&snapshot.beacon_state)))
-                .map_err(warp_utils::reject::beacon_chain_error)?,
-            _ => func(&self.state(chain)?),
-        }
-    }
-    */
-
-    /// Functions the same as `map_state` but additionally computes the value of
-    /// `execution_optimistic` of the state identified by `self`.
-    ///
-    /// This is to avoid re-instantiating `state` unnecessarily.
     pub fn map_state_and_execution_optimistic<T: BeaconChainTypes, F, U>(
         &self,
         chain: &BeaconChain<T>,