Persist eth1 cache (#760)

* Add intermediate structures for bytes conversion

* Expose byte conversion methods from `Eth1Service`

* Add eth1 ssz containers

* Fix type errors

* Load eth1 cache on restart

* Fix compile errors

* Update Cargo.lock

* Add comments and minor formatting

* Add test for eth1 cache persistence

* Restrict Deposit and Block cache field visibility

* Add checks

* Fix `SszDepositCache` check

* Implement Encode/Decode directly on `BlockCache`

beacon_node/eth1/src/inner.rs

@@ -1,6 +1,11 @@
 use crate::Config;
-use crate::{block_cache::BlockCache, deposit_cache::DepositCache};
+use crate::{
+    block_cache::BlockCache,
+    deposit_cache::{DepositCache, SszDepositCache},
+};
 use parking_lot::RwLock;
+use ssz::{Decode, Encode};
+use ssz_derive::{Decode, Encode};
 
 #[derive(Default)]
 pub struct DepositUpdater {
@@ -34,4 +39,47 @@ impl Inner {
             self.block_cache.write().truncate(block_cache_truncation);
         }
     }
+
+    /// Encode the eth1 block and deposit cache as bytes.
+    pub fn as_bytes(&self) -> Vec<u8> {
+        let ssz_eth1_cache = SszEth1Cache::from_inner(&self);
+        ssz_eth1_cache.as_ssz_bytes()
+    }
+
+    /// Recover `Inner` given byte representation of eth1 deposit and block caches.
+    pub fn from_bytes(bytes: &[u8], config: Config) -> Result<Self, String> {
+        let ssz_cache = SszEth1Cache::from_ssz_bytes(bytes)
+            .map_err(|e| format!("Ssz decoding error: {:?}", e))?;
+        Ok(ssz_cache.to_inner(config)?)
+    }
+}
+
+#[derive(Encode, Decode, Clone)]
+pub struct SszEth1Cache {
+    block_cache: BlockCache,
+    deposit_cache: SszDepositCache,
+    last_processed_block: Option<u64>,
+}
+
+impl SszEth1Cache {
+    pub fn from_inner(inner: &Inner) -> Self {
+        let deposit_updater = inner.deposit_cache.read();
+        let block_cache = inner.block_cache.read();
+        Self {
+            block_cache: (*block_cache).clone(),
+            deposit_cache: SszDepositCache::from_deposit_cache(&deposit_updater.cache),
+            last_processed_block: deposit_updater.last_processed_block,
+        }
+    }
+
+    pub fn to_inner(&self, config: Config) -> Result<Inner, String> {
+        Ok(Inner {
+            block_cache: RwLock::new(self.block_cache.clone()),
+            deposit_cache: RwLock::new(DepositUpdater {
+                cache: self.deposit_cache.to_deposit_cache()?,
+                last_processed_block: self.last_processed_block,
+            }),
+            config: RwLock::new(config),
+        })
+    }
 }