Implement slashing protection interchange format (#1544)

## Issue Addressed

Implements support for importing and exporting the slashing protection DB interchange format described here:

https://hackmd.io/@sproul/Bk0Y0qdGD

Also closes #1584 

## Proposed Changes

* [x] Support for serializing and deserializing the format
* [x] Support for importing and exporting Lighthouse's database
* [x] CLI commands to invoke import and export
* [x] Export to minimal format (required when a minimal format has been previously imported)
* [x] Tests for export to minimal (utilising mixed importing and attestation signing?)
* [x] Tests for import/export of complete format, and import of minimal format
* [x] ~~Prevent attestations with sources less than our max source (Danny's suggestion). Required for the fake attestation that we put in for the minimal format to block attestations from source 0.~~
* [x] Add the concept of a "low watermark" for compatibility with the minimal format

Bonus!

* [x] A fix to a potentially nasty bug involving validators getting re-registered each time the validator client ran! Thankfully, the ordering of keys meant that the validator IDs used for attestations and blocks remained stable -- otherwise we could have had some slashings on our hands! 😱
* [x] Tests to confirm that this bug is indeed vanquished

validator_client/slashing_protection/src/interchange.rs

@@ -0,0 +1,84 @@
+use serde_derive::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::iter::FromIterator;
+use types::{Epoch, Hash256, PublicKey, Slot};
+
+#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum InterchangeFormat {
+    Complete,
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct InterchangeMetadata {
+    pub interchange_format: InterchangeFormat,
+    #[serde(with = "serde_utils::quoted_u64::require_quotes")]
+    pub interchange_format_version: u64,
+    pub genesis_validators_root: Hash256,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CompleteInterchangeData {
+    pub pubkey: PublicKey,
+    pub signed_blocks: Vec<SignedBlock>,
+    pub signed_attestations: Vec<SignedAttestation>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct SignedBlock {
+    #[serde(with = "serde_utils::quoted_u64::require_quotes")]
+    pub slot: Slot,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signing_root: Option<Hash256>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct SignedAttestation {
+    #[serde(with = "serde_utils::quoted_u64::require_quotes")]
+    pub source_epoch: Epoch,
+    #[serde(with = "serde_utils::quoted_u64::require_quotes")]
+    pub target_epoch: Epoch,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signing_root: Option<Hash256>,
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub struct Interchange {
+    pub metadata: InterchangeMetadata,
+    pub data: Vec<CompleteInterchangeData>,
+}
+
+impl Interchange {
+    pub fn from_json_str(json: &str) -> Result<Self, serde_json::Error> {
+        serde_json::from_str(json)
+    }
+
+    pub fn from_json_reader(reader: impl std::io::Read) -> Result<Self, serde_json::Error> {
+        serde_json::from_reader(reader)
+    }
+
+    pub fn write_to(&self, writer: impl std::io::Write) -> Result<(), serde_json::Error> {
+        serde_json::to_writer(writer, self)
+    }
+
+    /// Do these two `Interchange`s contain the same data (ignoring ordering)?
+    pub fn equiv(&self, other: &Self) -> bool {
+        let self_set = HashSet::<_>::from_iter(self.data.iter());
+        let other_set = HashSet::<_>::from_iter(other.data.iter());
+        self.metadata == other.metadata && self_set == other_set
+    }
+
+    /// The number of entries in `data`.
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    /// Is the `data` part of the interchange completely empty?
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}