Implement freezer database (#508)

* Implement freezer database for state vectors

* Improve BeaconState safe accessors

And fix a bug in the compact committees accessor.

* Banish dodgy type bounds back to gRPC

* Clean up

* Switch to exclusive end points in chunked vec

* Cleaning up and start of tests

* Randao fix, more tests

* Fix unsightly hack

* Resolve test FIXMEs

* Config file support

* More clean-ups, migrator beginnings

* Finish migrator, integrate into BeaconChain

* Fixups

* Fix store tests

* Fix BeaconChain tests

* Fix LMD GHOST tests

* Address review comments, delete 'static bounds

* Cargo format

* Address review comments

* Fix LMD ghost tests

* Update to spec v0.9.0

* Update to v0.9.1

* Bump spec tags for v0.9.1

* Formatting, fix CI failures

* Resolve accidental KeyPair merge conflict

* Document new BeaconState functions

* Fix incorrect cache drops in `advance_caches`

* Update fork choice for v0.9.1

* Clean up some FIXMEs

* Fix a few docs/logs

* Update for new builder paradigm, spec changes

* Freezer DB integration into BeaconNode

* Cleaning up

* This works, clean it up

* Cleanups

* Fix and improve store tests

* Refine store test

* Delete unused beacon_chain_builder.rs

* Fix CLI

* Store state at split slot in hot database

* Make fork choice lookup fast again

* Store freezer DB split slot in the database

* Handle potential div by 0 in chunked_vector

* Exclude committee caches from freezer DB

* Remove FIXME about long-running test

beacon_node/store/src/memory_store.rs

@@ -1,23 +1,29 @@
 use super::{Error, Store};
+use crate::impls::beacon_state::{get_full_state, store_full_state};
 use parking_lot::RwLock;
 use std::collections::HashMap;
-use std::sync::Arc;
+use types::*;
 
 type DBHashMap = HashMap<Vec<u8>, Vec<u8>>;
 
 /// A thread-safe `HashMap` wrapper.
-#[derive(Clone)]
 pub struct MemoryStore {
-    // Note: this `Arc` is only included because of an artificial constraint by gRPC. Hopefully we
-    // can remove this one day.
-    db: Arc<RwLock<DBHashMap>>,
+    db: RwLock<DBHashMap>,
+}
+
+impl Clone for MemoryStore {
+    fn clone(&self) -> Self {
+        Self {
+            db: RwLock::new(self.db.read().clone()),
+        }
+    }
 }
 
 impl MemoryStore {
     /// Create a new, empty database.
     pub fn open() -> Self {
         Self {
-            db: Arc::new(RwLock::new(HashMap::new())),
+            db: RwLock::new(HashMap::new()),
         }
     }
 
@@ -64,4 +70,22 @@ impl Store for MemoryStore {
 
         Ok(())
     }
+
+    /// Store a state in the store.
+    fn put_state<E: EthSpec>(
+        &self,
+        state_root: &Hash256,
+        state: &BeaconState<E>,
+    ) -> Result<(), Error> {
+        store_full_state(self, state_root, state)
+    }
+
+    /// Fetch a state from the store.
+    fn get_state<E: EthSpec>(
+        &self,
+        state_root: &Hash256,
+        _: Option<Slot>,
+    ) -> Result<Option<BeaconState<E>>, Error> {
+        get_full_state(self, state_root)
+    }
 }