Implement checkpoint sync (#2244)

## Issue Addressed

Closes #1891
Closes #1784

## Proposed Changes

Implement checkpoint sync for Lighthouse, enabling it to start from a weak subjectivity checkpoint.

## Additional Info

- [x] Return unavailable status for out-of-range blocks requested by peers (#2561)
- [x] Implement sync daemon for fetching historical blocks (#2561)
- [x] Verify chain hashes (either in `historical_blocks.rs` or the calling module)
- [x] Consistency check for initial block + state
- [x] Fetch the initial state and block from a beacon node HTTP endpoint
- [x] Don't crash fetching beacon states by slot from the API
- [x] Background service for state reconstruction, triggered by CLI flag or API call.

Considered out of scope for this PR:

- Drop the requirement to provide the `--checkpoint-block` (this would require some pretty heavy refactoring of block verification)


Co-authored-by: Diva M <divma@protonmail.com>

lcli/src/parse_ssz.rs

@@ -1,13 +1,33 @@
 use clap::ArgMatches;
+use clap_utils::parse_required;
 use serde::Serialize;
 use ssz::Decode;
 use std::fs::File;
 use std::io::Read;
+use std::str::FromStr;
 use types::*;
 
+enum OutputFormat {
+    Json,
+    Yaml,
+}
+
+impl FromStr for OutputFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "json" => Ok(Self::Json),
+            "yaml" => Ok(Self::Yaml),
+            _ => Err(format!("Invalid output format \"{}\"", s)),
+        }
+    }
+}
+
 pub fn run_parse_ssz<T: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
     let type_str = matches.value_of("type").ok_or("No type supplied")?;
     let filename = matches.value_of("ssz-file").ok_or("No file supplied")?;
+    let format = parse_required(matches, "format")?;
 
     let mut bytes = vec![];
     let mut file =
@@ -19,24 +39,40 @@ pub fn run_parse_ssz<T: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
     info!("Type: {:?}", type_str);
 
     match type_str {
-        "block_base" => decode_and_print::<BeaconBlockBase<T>>(&bytes)?,
-        "block_altair" => decode_and_print::<BeaconBlockAltair<T>>(&bytes)?,
-        "state_base" => decode_and_print::<BeaconStateBase<T>>(&bytes)?,
-        "state_altair" => decode_and_print::<BeaconStateAltair<T>>(&bytes)?,
+        "signed_block_base" => decode_and_print::<SignedBeaconBlockBase<T>>(&bytes, format)?,
+        "signed_block_altair" => decode_and_print::<SignedBeaconBlockAltair<T>>(&bytes, format)?,
+        "block_base" => decode_and_print::<BeaconBlockBase<T>>(&bytes, format)?,
+        "block_altair" => decode_and_print::<BeaconBlockAltair<T>>(&bytes, format)?,
+        "state_base" => decode_and_print::<BeaconStateBase<T>>(&bytes, format)?,
+        "state_altair" => decode_and_print::<BeaconStateAltair<T>>(&bytes, format)?,
         other => return Err(format!("Unknown type: {}", other)),
     };
 
     Ok(())
 }
 
-fn decode_and_print<T: Decode + Serialize>(bytes: &[u8]) -> Result<(), String> {
+fn decode_and_print<T: Decode + Serialize>(
+    bytes: &[u8],
+    output_format: OutputFormat,
+) -> Result<(), String> {
     let item = T::from_ssz_bytes(bytes).map_err(|e| format!("SSZ decode failed: {:?}", e))?;
 
-    println!(
-        "{}",
-        serde_yaml::to_string(&item)
-            .map_err(|e| format!("Unable to write object to YAML: {:?}", e))?
-    );
+    match output_format {
+        OutputFormat::Json => {
+            println!(
+                "{}",
+                serde_json::to_string(&item)
+                    .map_err(|e| format!("Unable to write object to JSON: {:?}", e))?
+            );
+        }
+        OutputFormat::Yaml => {
+            println!(
+                "{}",
+                serde_yaml::to_string(&item)
+                    .map_err(|e| format!("Unable to write object to YAML: {:?}", e))?
+            );
+        }
+    }
 
     Ok(())
 }