Add validator_node, restructure binaries, gRPC.

This is a massive commit which restructures the workspace, adds a very
basic, untested, validator client and some very basic, non-functioning
gRPC endpoints to the beacon-node.

beacon_node/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "beacon_node"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+[dependencies]
+grpcio = { version = "0.4", default-features = false, features = ["protobuf-codec"] }
+protobuf = "2.0.2"
+protos = { path = "../protos" }
+clap = "2.32.0"
+db = { path = "db" }
+dirs = "1.0.3"
+futures = "0.1.23"
+slog = "^2.2.3"
+slog-term = "^2.4.0"
+slog-async = "^2.3.0"
+tokio = "0.1"

beacon_node/db/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "db"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+[dependencies]
+blake2-rfc = "0.2.18"
+bls = { path = "../../beacon_chain/utils/bls" }
+bytes = "0.4.10"
+rocksdb = "0.10.1"
+ssz = { path = "../../beacon_chain/utils/ssz" }
+types = { path = "../../beacon_chain/types" }

beacon_node/db/src/disk_db.rs

@@ -0,0 +1,196 @@
+extern crate rocksdb;
+
+use super::rocksdb::Error as RocksError;
+use super::rocksdb::{Options, DB};
+use super::{ClientDB, DBError, DBValue};
+use std::fs;
+use std::path::Path;
+
+/// A on-disk database which implements the ClientDB trait.
+///
+/// This implementation uses RocksDB with default options.
+pub struct DiskDB {
+    db: DB,
+}
+
+impl DiskDB {
+    /// Open the RocksDB database, optionally supplying columns if required.
+    ///
+    /// The RocksDB database will be contained in a directory titled
+    /// "database" in the supplied path.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the database is unable to be created.
+    pub fn open(path: &Path, columns: Option<&[&str]>) -> Self {
+        /*
+         * Initialise the options
+         */
+        let mut options = Options::default();
+        options.create_if_missing(true);
+
+        // TODO: ensure that columns are created (and remove
+        // the dead_code allow)
+
+        /*
+         * Initialise the path
+         */
+        fs::create_dir_all(&path).unwrap_or_else(|_| panic!("Unable to create {:?}", &path));
+        let db_path = path.join("database");
+
+        /*
+         * Open the database
+         */
+        let db = match columns {
+            None => DB::open(&options, db_path),
+            Some(columns) => DB::open_cf(&options, db_path, columns),
+        }.expect("Unable to open local database");;
+
+        Self { db }
+    }
+
+    /// Create a RocksDB column family. Corresponds to the
+    /// `create_cf()` function on the RocksDB API.
+    #[allow(dead_code)]
+    fn create_col(&mut self, col: &str) -> Result<(), DBError> {
+        match self.db.create_cf(col, &Options::default()) {
+            Err(e) => Err(e.into()),
+            Ok(_) => Ok(()),
+        }
+    }
+}
+
+impl From<RocksError> for DBError {
+    fn from(e: RocksError) -> Self {
+        Self {
+            message: e.to_string(),
+        }
+    }
+}
+
+impl ClientDB for DiskDB {
+    /// Get the value for some key on some column.
+    ///
+    /// Corresponds to the `get_cf()` method on the RocksDB API.
+    /// Will attempt to get the `ColumnFamily` and return an Err
+    /// if it fails.
+    fn get(&self, col: &str, key: &[u8]) -> Result<Option<DBValue>, DBError> {
+        match self.db.cf_handle(col) {
+            None => Err(DBError {
+                message: "Unknown column".to_string(),
+            }),
+            Some(handle) => match self.db.get_cf(handle, key)? {
+                None => Ok(None),
+                Some(db_vec) => Ok(Some(DBValue::from(&*db_vec))),
+            },
+        }
+    }
+
+    /// Set some value for some key on some column.
+    ///
+    /// Corresponds to the `cf_handle()` method on the RocksDB API.
+    /// Will attempt to get the `ColumnFamily` and return an Err
+    /// if it fails.
+    fn put(&self, col: &str, key: &[u8], val: &[u8]) -> Result<(), DBError> {
+        match self.db.cf_handle(col) {
+            None => Err(DBError {
+                message: "Unknown column".to_string(),
+            }),
+            Some(handle) => self.db.put_cf(handle, key, val).map_err(|e| e.into()),
+        }
+    }
+
+    /// Return true if some key exists in some column.
+    fn exists(&self, col: &str, key: &[u8]) -> Result<bool, DBError> {
+        /*
+         * I'm not sure if this is the correct way to read if some
+         * block exists. Naively I would expect this to unncessarily
+         * copy some data, but I could be wrong.
+         */
+        match self.db.cf_handle(col) {
+            None => Err(DBError {
+                message: "Unknown column".to_string(),
+            }),
+            Some(handle) => Ok(self.db.get_cf(handle, key)?.is_some()),
+        }
+    }
+
+    /// Delete the value for some key on some column.
+    ///
+    /// Corresponds to the `delete_cf()` method on the RocksDB API.
+    /// Will attempt to get the `ColumnFamily` and return an Err
+    /// if it fails.
+    fn delete(&self, col: &str, key: &[u8]) -> Result<(), DBError> {
+        match self.db.cf_handle(col) {
+            None => Err(DBError {
+                message: "Unknown column".to_string(),
+            }),
+            Some(handle) => {
+                self.db.delete_cf(handle, key)?;
+                Ok(())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::ClientDB;
+    use super::*;
+    use std::sync::Arc;
+    use std::{env, fs, thread};
+
+    #[test]
+    #[ignore]
+    fn test_rocksdb_can_use_db() {
+        let pwd = env::current_dir().unwrap();
+        let path = pwd.join("testdb_please_remove");
+        let _ = fs::remove_dir_all(&path);
+        fs::create_dir_all(&path).unwrap();
+
+        let col_name: &str = "TestColumn";
+        let column_families = vec![col_name];
+
+        let mut db = DiskDB::open(&path, None);
+
+        for cf in column_families {
+            db.create_col(&cf).unwrap();
+        }
+
+        let db = Arc::new(db);
+
+        let thread_count = 10;
+        let write_count = 10;
+
+        // We're execting the product of these numbers to fit in one byte.
+        assert!(thread_count * write_count <= 255);
+
+        let mut handles = vec![];
+        for t in 0..thread_count {
+            let wc = write_count;
+            let db = db.clone();
+            let col = col_name.clone();
+            let handle = thread::spawn(move || {
+                for w in 0..wc {
+                    let key = (t * w) as u8;
+                    let val = 42;
+                    db.put(&col, &vec![key], &vec![val]).unwrap();
+                }
+            });
+            handles.push(handle);
+        }
+
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        for t in 0..thread_count {
+            for w in 0..write_count {
+                let key = (t * w) as u8;
+                let val = db.get(&col_name, &vec![key]).unwrap().unwrap();
+                assert_eq!(vec![42], val);
+            }
+        }
+        fs::remove_dir_all(&path).unwrap();
+    }
+}

beacon_node/db/src/lib.rs

@@ -0,0 +1,14 @@
+extern crate blake2_rfc as blake2;
+extern crate bls;
+extern crate rocksdb;
+
+mod disk_db;
+mod memory_db;
+pub mod stores;
+mod traits;
+
+use self::stores::COLUMNS;
+
+pub use self::disk_db::DiskDB;
+pub use self::memory_db::MemoryDB;
+pub use self::traits::{ClientDB, DBError, DBValue};

beacon_node/db/src/memory_db.rs

@@ -0,0 +1,236 @@
+use super::blake2::blake2b::blake2b;
+use super::COLUMNS;
+use super::{ClientDB, DBError, DBValue};
+use std::collections::{HashMap, HashSet};
+use std::sync::RwLock;
+
+type DBHashMap = HashMap<Vec<u8>, Vec<u8>>;
+type ColumnHashSet = HashSet<String>;
+
+/// An in-memory database implementing the ClientDB trait.
+///
+/// It is not particularily optimized, it exists for ease and speed of testing. It's not expected
+/// this DB would be used outside of tests.
+pub struct MemoryDB {
+    db: RwLock<DBHashMap>,
+    known_columns: RwLock<ColumnHashSet>,
+}
+
+impl MemoryDB {
+    /// Open the in-memory database.
+    ///
+    /// All columns must be supplied initially, you will get an error if you try to access a column
+    /// that was not declared here. This condition is enforced artificially to simulate RocksDB.
+    pub fn open() -> Self {
+        let db: DBHashMap = HashMap::new();
+        let mut known_columns: ColumnHashSet = HashSet::new();
+        for col in &COLUMNS {
+            known_columns.insert(col.to_string());
+        }
+        Self {
+            db: RwLock::new(db),
+            known_columns: RwLock::new(known_columns),
+        }
+    }
+
+    /// Hashes a key and a column name in order to get a unique key for the supplied column.
+    fn get_key_for_col(col: &str, key: &[u8]) -> Vec<u8> {
+        blake2b(32, col.as_bytes(), key).as_bytes().to_vec()
+    }
+}
+
+impl ClientDB for MemoryDB {
+    /// Get the value of some key from the database. Returns `None` if the key does not exist.
+    fn get(&self, col: &str, key: &[u8]) -> Result<Option<DBValue>, DBError> {
+        // Panic if the DB locks are poisoned.
+        let db = self.db.read().unwrap();
+        let known_columns = self.known_columns.read().unwrap();
+
+        if known_columns.contains(&col.to_string()) {
+            let column_key = MemoryDB::get_key_for_col(col, key);
+            Ok(db.get(&column_key).and_then(|val| Some(val.clone())))
+        } else {
+            Err(DBError {
+                message: "Unknown column".to_string(),
+            })
+        }
+    }
+
+    /// Puts a key in the database.
+    fn put(&self, col: &str, key: &[u8], val: &[u8]) -> Result<(), DBError> {
+        // Panic if the DB locks are poisoned.
+        let mut db = self.db.write().unwrap();
+        let known_columns = self.known_columns.read().unwrap();
+
+        if known_columns.contains(&col.to_string()) {
+            let column_key = MemoryDB::get_key_for_col(col, key);
+            db.insert(column_key, val.to_vec());
+            Ok(())
+        } else {
+            Err(DBError {
+                message: "Unknown column".to_string(),
+            })
+        }
+    }
+
+    /// Return true if some key exists in some column.
+    fn exists(&self, col: &str, key: &[u8]) -> Result<bool, DBError> {
+        // Panic if the DB locks are poisoned.
+        let db = self.db.read().unwrap();
+        let known_columns = self.known_columns.read().unwrap();
+
+        if known_columns.contains(&col.to_string()) {
+            let column_key = MemoryDB::get_key_for_col(col, key);
+            Ok(db.contains_key(&column_key))
+        } else {
+            Err(DBError {
+                message: "Unknown column".to_string(),
+            })
+        }
+    }
+
+    /// Delete some key from the database.
+    fn delete(&self, col: &str, key: &[u8]) -> Result<(), DBError> {
+        // Panic if the DB locks are poisoned.
+        let mut db = self.db.write().unwrap();
+        let known_columns = self.known_columns.read().unwrap();
+
+        if known_columns.contains(&col.to_string()) {
+            let column_key = MemoryDB::get_key_for_col(col, key);
+            db.remove(&column_key);
+            Ok(())
+        } else {
+            Err(DBError {
+                message: "Unknown column".to_string(),
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::stores::{BLOCKS_DB_COLUMN, VALIDATOR_DB_COLUMN};
+    use super::super::ClientDB;
+    use super::*;
+    use std::sync::Arc;
+    use std::thread;
+
+    #[test]
+    fn test_memorydb_can_delete() {
+        let col_a: &str = BLOCKS_DB_COLUMN;
+
+        let db = MemoryDB::open();
+
+        db.put(col_a, "dogs".as_bytes(), "lol".as_bytes()).unwrap();
+
+        assert_eq!(
+            db.get(col_a, "dogs".as_bytes()).unwrap().unwrap(),
+            "lol".as_bytes()
+        );
+
+        db.delete(col_a, "dogs".as_bytes()).unwrap();
+
+        assert_eq!(db.get(col_a, "dogs".as_bytes()).unwrap(), None);
+    }
+
+    #[test]
+    fn test_memorydb_column_access() {
+        let col_a: &str = BLOCKS_DB_COLUMN;
+        let col_b: &str = VALIDATOR_DB_COLUMN;
+
+        let db = MemoryDB::open();
+
+        /*
+         * Testing that if we write to the same key in different columns that
+         * there is not an overlap.
+         */
+        db.put(col_a, "same".as_bytes(), "cat".as_bytes()).unwrap();
+        db.put(col_b, "same".as_bytes(), "dog".as_bytes()).unwrap();
+
+        assert_eq!(
+            db.get(col_a, "same".as_bytes()).unwrap().unwrap(),
+            "cat".as_bytes()
+        );
+        assert_eq!(
+            db.get(col_b, "same".as_bytes()).unwrap().unwrap(),
+            "dog".as_bytes()
+        );
+    }
+
+    #[test]
+    fn test_memorydb_unknown_column_access() {
+        let col_a: &str = BLOCKS_DB_COLUMN;
+        let col_x: &str = "ColumnX";
+
+        let db = MemoryDB::open();
+
+        /*
+         * Test that we get errors when using undeclared columns
+         */
+        assert!(db.put(col_a, "cats".as_bytes(), "lol".as_bytes()).is_ok());
+        assert!(db.put(col_x, "cats".as_bytes(), "lol".as_bytes()).is_err());
+
+        assert!(db.get(col_a, "cats".as_bytes()).is_ok());
+        assert!(db.get(col_x, "cats".as_bytes()).is_err());
+    }
+
+    #[test]
+    fn test_memorydb_exists() {
+        let col_a: &str = BLOCKS_DB_COLUMN;
+        let col_b: &str = VALIDATOR_DB_COLUMN;
+
+        let db = MemoryDB::open();
+
+        /*
+         * Testing that if we write to the same key in different columns that
+         * there is not an overlap.
+         */
+        db.put(col_a, "cats".as_bytes(), "lol".as_bytes()).unwrap();
+
+        assert_eq!(true, db.exists(col_a, "cats".as_bytes()).unwrap());
+        assert_eq!(false, db.exists(col_b, "cats".as_bytes()).unwrap());
+
+        assert_eq!(false, db.exists(col_a, "dogs".as_bytes()).unwrap());
+        assert_eq!(false, db.exists(col_b, "dogs".as_bytes()).unwrap());
+    }
+
+    #[test]
+    fn test_memorydb_threading() {
+        let col_name: &str = BLOCKS_DB_COLUMN;
+
+        let db = Arc::new(MemoryDB::open());
+
+        let thread_count = 10;
+        let write_count = 10;
+
+        // We're execting the product of these numbers to fit in one byte.
+        assert!(thread_count * write_count <= 255);
+
+        let mut handles = vec![];
+        for t in 0..thread_count {
+            let wc = write_count;
+            let db = db.clone();
+            let col = col_name.clone();
+            let handle = thread::spawn(move || {
+                for w in 0..wc {
+                    let key = (t * w) as u8;
+                    let val = 42;
+                    db.put(&col, &vec![key], &vec![val]).unwrap();
+                }
+            });
+            handles.push(handle);
+        }
+
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        for t in 0..thread_count {
+            for w in 0..write_count {
+                let key = (t * w) as u8;
+                let val = db.get(&col_name, &vec![key]).unwrap().unwrap();
+                assert_eq!(vec![42], val);
+            }
+        }
+    }
+}

beacon_node/db/src/stores/beacon_block_store.rs

@@ -0,0 +1,249 @@
+use super::BLOCKS_DB_COLUMN as DB_COLUMN;
+use super::{ClientDB, DBError};
+use ssz::Decodable;
+use std::sync::Arc;
+use types::{readers::BeaconBlockReader, BeaconBlock, Hash256};
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum BeaconBlockAtSlotError {
+    UnknownBeaconBlock,
+    InvalidBeaconBlock,
+    DBError(String),
+}
+
+pub struct BeaconBlockStore<T>
+where
+    T: ClientDB,
+{
+    db: Arc<T>,
+}
+
+// Implements `put`, `get`, `exists` and `delete` for the store.
+impl_crud_for_store!(BeaconBlockStore, DB_COLUMN);
+
+impl<T: ClientDB> BeaconBlockStore<T> {
+    pub fn new(db: Arc<T>) -> Self {
+        Self { db }
+    }
+
+    /// Retuns an object implementing `BeaconBlockReader`, or `None` (if hash not known).
+    ///
+    /// Note: Presently, this function fully deserializes a `BeaconBlock` and returns that. In the
+    /// future, it would be ideal to return an object capable of reading directly from serialized
+    /// SSZ bytes.
+    pub fn get_reader(&self, hash: &Hash256) -> Result<Option<impl BeaconBlockReader>, DBError> {
+        match self.get(&hash)? {
+            None => Ok(None),
+            Some(ssz) => {
+                let (block, _) = BeaconBlock::ssz_decode(&ssz, 0).map_err(|_| DBError {
+                    message: "Bad BeaconBlock SSZ.".to_string(),
+                })?;
+                Ok(Some(block))
+            }
+        }
+    }
+
+    /// Retrieve the block at a slot given a "head_hash" and a slot.
+    ///
+    /// A "head_hash" must be a block hash with a slot number greater than or equal to the desired
+    /// slot.
+    ///
+    /// This function will read each block down the chain until it finds a block with the given
+    /// slot number. If the slot is skipped, the function will return None.
+    ///
+    /// If a block is found, a tuple of (block_hash, serialized_block) is returned.
+    ///
+    /// Note: this function uses a loop instead of recursion as the compiler is over-strict when it
+    /// comes to recursion and the `impl Trait` pattern. See:
+    /// https://stackoverflow.com/questions/54032940/using-impl-trait-in-a-recursive-function
+    pub fn block_at_slot(
+        &self,
+        head_hash: &Hash256,
+        slot: u64,
+    ) -> Result<Option<(Hash256, impl BeaconBlockReader)>, BeaconBlockAtSlotError> {
+        let mut current_hash = *head_hash;
+
+        loop {
+            if let Some(block_reader) = self.get_reader(&current_hash)? {
+                if block_reader.slot() == slot {
+                    break Ok(Some((current_hash, block_reader)));
+                } else if block_reader.slot() < slot {
+                    break Ok(None);
+                } else {
+                    current_hash = block_reader.parent_root();
+                }
+            } else {
+                break Err(BeaconBlockAtSlotError::UnknownBeaconBlock);
+            }
+        }
+    }
+}
+
+impl From<DBError> for BeaconBlockAtSlotError {
+    fn from(e: DBError) -> Self {
+        BeaconBlockAtSlotError::DBError(e.message)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::super::MemoryDB;
+    use super::*;
+
+    use std::sync::Arc;
+    use std::thread;
+
+    use ssz::ssz_encode;
+    use types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use types::BeaconBlock;
+    use types::Hash256;
+
+    test_crud_for_store!(BeaconBlockStore, DB_COLUMN);
+
+    #[test]
+    fn head_hash_slot_too_low() {
+        let db = Arc::new(MemoryDB::open());
+        let bs = Arc::new(BeaconBlockStore::new(db.clone()));
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+
+        let mut block = BeaconBlock::random_for_test(&mut rng);
+        block.slot = 10;
+
+        let block_root = block.canonical_root();
+        bs.put(&block_root, &ssz_encode(&block)).unwrap();
+
+        let result = bs.block_at_slot(&block_root, 11).unwrap();
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_invalid_block_at_slot() {
+        let db = Arc::new(MemoryDB::open());
+        let store = BeaconBlockStore::new(db.clone());
+
+        let ssz = "definitly not a valid block".as_bytes();
+        let hash = &Hash256::from("some hash".as_bytes());
+
+        db.put(DB_COLUMN, hash, ssz).unwrap();
+        assert_eq!(
+            store.block_at_slot(hash, 42),
+            Err(BeaconBlockAtSlotError::DBError(
+                "Bad BeaconBlock SSZ.".into()
+            ))
+        );
+    }
+
+    #[test]
+    fn test_unknown_block_at_slot() {
+        let db = Arc::new(MemoryDB::open());
+        let store = BeaconBlockStore::new(db.clone());
+
+        let ssz = "some bytes".as_bytes();
+        let hash = &Hash256::from("some hash".as_bytes());
+        let other_hash = &Hash256::from("another hash".as_bytes());
+
+        db.put(DB_COLUMN, hash, ssz).unwrap();
+        assert_eq!(
+            store.block_at_slot(other_hash, 42),
+            Err(BeaconBlockAtSlotError::UnknownBeaconBlock)
+        );
+    }
+
+    #[test]
+    fn test_block_store_on_memory_db() {
+        let db = Arc::new(MemoryDB::open());
+        let bs = Arc::new(BeaconBlockStore::new(db.clone()));
+
+        let thread_count = 10;
+        let write_count = 10;
+
+        // We're expecting the product of these numbers to fit in one byte.
+        assert!(thread_count * write_count <= 255);
+
+        let mut handles = vec![];
+        for t in 0..thread_count {
+            let wc = write_count;
+            let bs = bs.clone();
+            let handle = thread::spawn(move || {
+                for w in 0..wc {
+                    let key = (t * w) as u8;
+                    let val = 42;
+                    bs.put(&[key][..].into(), &vec![val]).unwrap();
+                }
+            });
+            handles.push(handle);
+        }
+
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        for t in 0..thread_count {
+            for w in 0..write_count {
+                let key = (t * w) as u8;
+                assert!(bs.exists(&[key][..].into()).unwrap());
+                let val = bs.get(&[key][..].into()).unwrap().unwrap();
+                assert_eq!(vec![42], val);
+            }
+        }
+    }
+
+    #[test]
+    fn test_block_at_slot() {
+        let db = Arc::new(MemoryDB::open());
+        let bs = Arc::new(BeaconBlockStore::new(db.clone()));
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+
+        // Specify test block parameters.
+        let hashes = [
+            Hash256::from(&[0; 32][..]),
+            Hash256::from(&[1; 32][..]),
+            Hash256::from(&[2; 32][..]),
+            Hash256::from(&[3; 32][..]),
+            Hash256::from(&[4; 32][..]),
+        ];
+        let parent_hashes = [
+            Hash256::from(&[255; 32][..]), // Genesis block.
+            Hash256::from(&[0; 32][..]),
+            Hash256::from(&[1; 32][..]),
+            Hash256::from(&[2; 32][..]),
+            Hash256::from(&[3; 32][..]),
+        ];
+        let slots = [0, 1, 3, 4, 5];
+
+        // Generate a vec of random blocks and store them in the DB.
+        let block_count = 5;
+        let mut blocks: Vec<BeaconBlock> = Vec::with_capacity(5);
+        for i in 0..block_count {
+            let mut block = BeaconBlock::random_for_test(&mut rng);
+
+            block.parent_root = parent_hashes[i];
+            block.slot = slots[i];
+
+            let ssz = ssz_encode(&block);
+            db.put(DB_COLUMN, &hashes[i], &ssz).unwrap();
+
+            blocks.push(block);
+        }
+
+        // Test that certain slots can be reached from certain hashes.
+        let test_cases = vec![(4, 4), (4, 3), (4, 2), (4, 1), (4, 0)];
+        for (hashes_index, slot_index) in test_cases {
+            let (matched_block_hash, reader) = bs
+                .block_at_slot(&hashes[hashes_index], slots[slot_index])
+                .unwrap()
+                .unwrap();
+            assert_eq!(matched_block_hash, hashes[slot_index]);
+            assert_eq!(reader.slot(), slots[slot_index]);
+        }
+
+        let ssz = bs.block_at_slot(&hashes[4], 2).unwrap();
+        assert_eq!(ssz, None);
+
+        let ssz = bs.block_at_slot(&hashes[4], 6).unwrap();
+        assert_eq!(ssz, None);
+
+        let ssz = bs.block_at_slot(&Hash256::from("unknown".as_bytes()), 2);
+        assert_eq!(ssz, Err(BeaconBlockAtSlotError::UnknownBeaconBlock));
+    }
+}

beacon_node/db/src/stores/beacon_state_store.rs

@@ -0,0 +1,68 @@
+use super::STATES_DB_COLUMN as DB_COLUMN;
+use super::{ClientDB, DBError};
+use ssz::Decodable;
+use std::sync::Arc;
+use types::{readers::BeaconStateReader, BeaconState, Hash256};
+
+pub struct BeaconStateStore<T>
+where
+    T: ClientDB,
+{
+    db: Arc<T>,
+}
+
+// Implements `put`, `get`, `exists` and `delete` for the store.
+impl_crud_for_store!(BeaconStateStore, DB_COLUMN);
+
+impl<T: ClientDB> BeaconStateStore<T> {
+    pub fn new(db: Arc<T>) -> Self {
+        Self { db }
+    }
+
+    /// Retuns an object implementing `BeaconStateReader`, or `None` (if hash not known).
+    ///
+    /// Note: Presently, this function fully deserializes a `BeaconState` and returns that. In the
+    /// future, it would be ideal to return an object capable of reading directly from serialized
+    /// SSZ bytes.
+    pub fn get_reader(&self, hash: &Hash256) -> Result<Option<impl BeaconStateReader>, DBError> {
+        match self.get(&hash)? {
+            None => Ok(None),
+            Some(ssz) => {
+                let (state, _) = BeaconState::ssz_decode(&ssz, 0).map_err(|_| DBError {
+                    message: "Bad State SSZ.".to_string(),
+                })?;
+                Ok(Some(state))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::super::MemoryDB;
+    use super::*;
+
+    use std::sync::Arc;
+    use ssz::ssz_encode;
+    use types::Hash256;
+    use types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+
+    test_crud_for_store!(BeaconStateStore, DB_COLUMN);
+
+    #[test]
+    fn test_reader() {
+        let db = Arc::new(MemoryDB::open());
+        let store = BeaconStateStore::new(db.clone());
+
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let state = BeaconState::random_for_test(&mut rng);
+        let state_root = state.canonical_root();
+
+        store.put(&state_root, &ssz_encode(&state)).unwrap();
+
+        let reader = store.get_reader(&state_root).unwrap().unwrap();
+        let decoded = reader.into_beacon_state().unwrap();
+
+        assert_eq!(state, decoded);
+    }
+}

beacon_node/db/src/stores/macros.rs

@@ -0,0 +1,103 @@
+macro_rules! impl_crud_for_store {
+    ($store: ident, $db_column: expr) => {
+        impl<T: ClientDB> $store<T> {
+            pub fn put(&self, hash: &Hash256, ssz: &[u8]) -> Result<(), DBError> {
+                self.db.put($db_column, hash, ssz)
+            }
+
+            pub fn get(&self, hash: &Hash256) -> Result<Option<Vec<u8>>, DBError> {
+                self.db.get($db_column, hash)
+            }
+
+            pub fn exists(&self, hash: &Hash256) -> Result<bool, DBError> {
+                self.db.exists($db_column, hash)
+            }
+
+            pub fn delete(&self, hash: &Hash256) -> Result<(), DBError> {
+                self.db.delete($db_column, hash)
+            }
+        }
+    };
+}
+
+#[allow(unused_macros)]
+macro_rules! test_crud_for_store {
+    ($store: ident, $db_column: expr) => {
+        #[test]
+        fn test_put() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+
+            store.put(hash, ssz).unwrap();
+            assert_eq!(db.get(DB_COLUMN, hash).unwrap().unwrap(), ssz);
+        }
+
+        #[test]
+        fn test_get() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+
+            db.put(DB_COLUMN, hash, ssz).unwrap();
+            assert_eq!(store.get(hash).unwrap().unwrap(), ssz);
+        }
+
+        #[test]
+        fn test_get_unknown() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+            let other_hash = &Hash256::from("another hash".as_bytes());
+
+            db.put(DB_COLUMN, other_hash, ssz).unwrap();
+            assert_eq!(store.get(hash).unwrap(), None);
+        }
+
+        #[test]
+        fn test_exists() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+
+            db.put(DB_COLUMN, hash, ssz).unwrap();
+            assert!(store.exists(hash).unwrap());
+        }
+
+        #[test]
+        fn test_block_does_not_exist() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+            let other_hash = &Hash256::from("another hash".as_bytes());
+
+            db.put(DB_COLUMN, hash, ssz).unwrap();
+            assert!(!store.exists(other_hash).unwrap());
+        }
+
+        #[test]
+        fn test_delete() {
+            let db = Arc::new(MemoryDB::open());
+            let store = $store::new(db.clone());
+
+            let ssz = "some bytes".as_bytes();
+            let hash = &Hash256::from("some hash".as_bytes());
+
+            db.put(DB_COLUMN, hash, ssz).unwrap();
+            assert!(db.exists(DB_COLUMN, hash).unwrap());
+
+            store.delete(hash).unwrap();
+            assert!(!db.exists(DB_COLUMN, hash).unwrap());
+        }
+    };
+}

beacon_node/db/src/stores/mod.rs

@@ -0,0 +1,27 @@
+use super::{ClientDB, DBError};
+
+#[macro_use]
+mod macros;
+mod beacon_block_store;
+mod beacon_state_store;
+mod pow_chain_store;
+mod validator_store;
+
+pub use self::beacon_block_store::{BeaconBlockAtSlotError, BeaconBlockStore};
+pub use self::beacon_state_store::BeaconStateStore;
+pub use self::pow_chain_store::PoWChainStore;
+pub use self::validator_store::{ValidatorStore, ValidatorStoreError};
+
+use super::bls;
+
+pub const BLOCKS_DB_COLUMN: &str = "blocks";
+pub const STATES_DB_COLUMN: &str = "states";
+pub const POW_CHAIN_DB_COLUMN: &str = "powchain";
+pub const VALIDATOR_DB_COLUMN: &str = "validator";
+
+pub const COLUMNS: [&str; 4] = [
+    BLOCKS_DB_COLUMN,
+    STATES_DB_COLUMN,
+    POW_CHAIN_DB_COLUMN,
+    VALIDATOR_DB_COLUMN,
+];

beacon_node/db/src/stores/pow_chain_store.rs

@@ -0,0 +1,68 @@
+use super::POW_CHAIN_DB_COLUMN as DB_COLUMN;
+use super::{ClientDB, DBError};
+use std::sync::Arc;
+
+pub struct PoWChainStore<T>
+where
+    T: ClientDB,
+{
+    db: Arc<T>,
+}
+
+impl<T: ClientDB> PoWChainStore<T> {
+    pub fn new(db: Arc<T>) -> Self {
+        Self { db }
+    }
+
+    pub fn put_block_hash(&self, hash: &[u8]) -> Result<(), DBError> {
+        self.db.put(DB_COLUMN, hash, &[0])
+    }
+
+    pub fn block_hash_exists(&self, hash: &[u8]) -> Result<bool, DBError> {
+        self.db.exists(DB_COLUMN, hash)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate types;
+
+    use super::super::super::MemoryDB;
+    use super::*;
+
+    use self::types::Hash256;
+
+    #[test]
+    fn test_put_block_hash() {
+        let db = Arc::new(MemoryDB::open());
+        let store = PoWChainStore::new(db.clone());
+
+        let hash = &Hash256::from("some hash".as_bytes()).to_vec();
+        store.put_block_hash(hash).unwrap();
+
+        assert!(db.exists(DB_COLUMN, hash).unwrap());
+    }
+
+    #[test]
+    fn test_block_hash_exists() {
+        let db = Arc::new(MemoryDB::open());
+        let store = PoWChainStore::new(db.clone());
+
+        let hash = &Hash256::from("some hash".as_bytes()).to_vec();
+        db.put(DB_COLUMN, hash, &[0]).unwrap();
+
+        assert!(store.block_hash_exists(hash).unwrap());
+    }
+
+    #[test]
+    fn test_block_hash_does_not_exist() {
+        let db = Arc::new(MemoryDB::open());
+        let store = PoWChainStore::new(db.clone());
+
+        let hash = &Hash256::from("some hash".as_bytes()).to_vec();
+        let other_hash = &Hash256::from("another hash".as_bytes()).to_vec();
+        db.put(DB_COLUMN, hash, &[0]).unwrap();
+
+        assert!(!store.block_hash_exists(other_hash).unwrap());
+    }
+}

beacon_node/db/src/stores/validator_store.rs

@@ -0,0 +1,215 @@
+extern crate bytes;
+
+use self::bytes::{BufMut, BytesMut};
+use super::bls::PublicKey;
+use super::VALIDATOR_DB_COLUMN as DB_COLUMN;
+use super::{ClientDB, DBError};
+use ssz::{ssz_encode, Decodable};
+use std::sync::Arc;
+
+#[derive(Debug, PartialEq)]
+pub enum ValidatorStoreError {
+    DBError(String),
+    DecodeError,
+}
+
+impl From<DBError> for ValidatorStoreError {
+    fn from(error: DBError) -> Self {
+        ValidatorStoreError::DBError(error.message)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum KeyPrefixes {
+    PublicKey,
+}
+
+pub struct ValidatorStore<T>
+where
+    T: ClientDB,
+{
+    db: Arc<T>,
+}
+
+impl<T: ClientDB> ValidatorStore<T> {
+    pub fn new(db: Arc<T>) -> Self {
+        Self { db }
+    }
+
+    fn prefix_bytes(&self, key_prefix: &KeyPrefixes) -> Vec<u8> {
+        match key_prefix {
+            KeyPrefixes::PublicKey => b"pubkey".to_vec(),
+        }
+    }
+
+    fn get_db_key_for_index(&self, key_prefix: &KeyPrefixes, index: usize) -> Vec<u8> {
+        let mut buf = BytesMut::with_capacity(6 + 8);
+        buf.put(self.prefix_bytes(key_prefix));
+        buf.put_u64_be(index as u64);
+        buf.take().to_vec()
+    }
+
+    pub fn put_public_key_by_index(
+        &self,
+        index: usize,
+        public_key: &PublicKey,
+    ) -> Result<(), ValidatorStoreError> {
+        let key = self.get_db_key_for_index(&KeyPrefixes::PublicKey, index);
+        let val = ssz_encode(public_key);
+        self.db
+            .put(DB_COLUMN, &key[..], &val[..])
+            .map_err(ValidatorStoreError::from)
+    }
+
+    pub fn get_public_key_by_index(
+        &self,
+        index: usize,
+    ) -> Result<Option<PublicKey>, ValidatorStoreError> {
+        let key = self.get_db_key_for_index(&KeyPrefixes::PublicKey, index);
+        let val = self.db.get(DB_COLUMN, &key[..])?;
+        match val {
+            None => Ok(None),
+            Some(val) => match PublicKey::ssz_decode(&val, 0) {
+                Ok((key, _)) => Ok(Some(key)),
+                Err(_) => Err(ValidatorStoreError::DecodeError),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::super::MemoryDB;
+    use super::super::bls::Keypair;
+    use super::*;
+
+    #[test]
+    fn test_prefix_bytes() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        assert_eq!(
+            store.prefix_bytes(&KeyPrefixes::PublicKey),
+            b"pubkey".to_vec()
+        );
+    }
+
+    #[test]
+    fn test_get_db_key_for_index() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        let mut buf = BytesMut::with_capacity(6 + 8);
+        buf.put(b"pubkey".to_vec());
+        buf.put_u64_be(42);
+        assert_eq!(
+            store.get_db_key_for_index(&KeyPrefixes::PublicKey, 42),
+            buf.take().to_vec()
+        )
+    }
+
+    #[test]
+    fn test_put_public_key_by_index() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        let index = 3;
+        let public_key = Keypair::random().pk;
+
+        store.put_public_key_by_index(index, &public_key).unwrap();
+        let public_key_at_index = db
+            .get(
+                DB_COLUMN,
+                &store.get_db_key_for_index(&KeyPrefixes::PublicKey, index)[..],
+            )
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(public_key_at_index, ssz_encode(&public_key));
+    }
+
+    #[test]
+    fn test_get_public_key_by_index() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        let index = 4;
+        let public_key = Keypair::random().pk;
+
+        db.put(
+            DB_COLUMN,
+            &store.get_db_key_for_index(&KeyPrefixes::PublicKey, index)[..],
+            &ssz_encode(&public_key)[..],
+        )
+        .unwrap();
+
+        let public_key_at_index = store.get_public_key_by_index(index).unwrap().unwrap();
+        assert_eq!(public_key_at_index, public_key);
+    }
+
+    #[test]
+    fn test_get_public_key_by_unknown_index() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        let public_key = Keypair::random().pk;
+
+        db.put(
+            DB_COLUMN,
+            &store.get_db_key_for_index(&KeyPrefixes::PublicKey, 3)[..],
+            &ssz_encode(&public_key)[..],
+        )
+        .unwrap();
+
+        let public_key_at_index = store.get_public_key_by_index(4).unwrap();
+        assert_eq!(public_key_at_index, None);
+    }
+
+    #[test]
+    fn test_get_invalid_public_key() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db.clone());
+
+        let key = store.get_db_key_for_index(&KeyPrefixes::PublicKey, 42);
+        db.put(DB_COLUMN, &key[..], "cats".as_bytes()).unwrap();
+
+        assert_eq!(
+            store.get_public_key_by_index(42),
+            Err(ValidatorStoreError::DecodeError)
+        );
+    }
+
+    #[test]
+    fn test_validator_store_put_get() {
+        let db = Arc::new(MemoryDB::open());
+        let store = ValidatorStore::new(db);
+
+        let keys = vec![
+            Keypair::random(),
+            Keypair::random(),
+            Keypair::random(),
+            Keypair::random(),
+            Keypair::random(),
+        ];
+
+        for i in 0..keys.len() {
+            store.put_public_key_by_index(i, &keys[i].pk).unwrap();
+        }
+
+        /*
+         * Check all keys are retrieved correctly.
+         */
+        for i in 0..keys.len() {
+            let retrieved = store.get_public_key_by_index(i).unwrap().unwrap();
+            assert_eq!(retrieved, keys[i].pk);
+        }
+
+        /*
+         * Check that an index that wasn't stored returns None.
+         */
+        assert!(store
+            .get_public_key_by_index(keys.len() + 1)
+            .unwrap()
+            .is_none());
+    }
+}

beacon_node/db/src/traits.rs

@@ -0,0 +1,28 @@
+pub type DBValue = Vec<u8>;
+
+#[derive(Debug)]
+pub struct DBError {
+    pub message: String,
+}
+
+impl DBError {
+    pub fn new(message: String) -> Self {
+        Self { message }
+    }
+}
+
+/// A generic database to be used by the "client' (i.e.,
+/// the lighthouse blockchain client).
+///
+/// The purpose of having this generic trait is to allow the
+/// program to use a persistent on-disk database during production,
+/// but use a transient database during tests.
+pub trait ClientDB: Sync + Send {
+    fn get(&self, col: &str, key: &[u8]) -> Result<Option<DBValue>, DBError>;
+
+    fn put(&self, col: &str, key: &[u8], val: &[u8]) -> Result<(), DBError>;
+
+    fn exists(&self, col: &str, key: &[u8]) -> Result<bool, DBError>;
+
+    fn delete(&self, col: &str, key: &[u8]) -> Result<(), DBError>;
+}

beacon_node/src/beacon_chain/block_processing.rs

@@ -0,0 +1,72 @@
+use super::{BeaconChain, ClientDB, DBError, SlotClock};
+use slot_clock::TestingSlotClockError;
+use ssz::{ssz_encode, Encodable};
+use types::{readers::BeaconBlockReader, Hash256};
+
+#[derive(Debug, PartialEq)]
+pub enum Outcome {
+    FutureSlot,
+    Processed,
+
+    NewCanonicalBlock,
+    NewReorgBlock,
+    NewForkBlock,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    DBError(String),
+    NotImplemented,
+    PresentSlotIsNone,
+}
+
+impl<T, U> BeaconChain<T, U>
+where
+    T: ClientDB,
+    U: SlotClock,
+    Error: From<<U as SlotClock>::Error>,
+{
+    pub fn process_block<V>(&mut self, block: &V) -> Result<(Outcome, Hash256), Error>
+    where
+        V: BeaconBlockReader + Encodable + Sized,
+    {
+        let block_root = block.canonical_root();
+
+        let present_slot = self
+            .slot_clock
+            .present_slot()?
+            .ok_or(Error::PresentSlotIsNone)?;
+
+        // Block from future slots (i.e., greater than the present slot) should not be processed.
+        if block.slot() > present_slot {
+            return Ok((Outcome::FutureSlot, block_root));
+        }
+
+        // TODO: block processing has been removed.
+        // https://github.com/sigp/lighthouse/issues/98
+
+        // Update leaf blocks.
+        self.block_store.put(&block_root, &ssz_encode(block)[..])?;
+        if self.leaf_blocks.contains(&block.parent_root()) {
+            self.leaf_blocks.remove(&block.parent_root());
+        }
+        if self.canonical_leaf_block == block.parent_root() {
+            self.canonical_leaf_block = block_root;
+        }
+        self.leaf_blocks.insert(block_root);
+
+        Ok((Outcome::Processed, block_root))
+    }
+}
+
+impl From<DBError> for Error {
+    fn from(e: DBError) -> Error {
+        Error::DBError(e.message)
+    }
+}
+
+impl From<TestingSlotClockError> for Error {
+    fn from(_: TestingSlotClockError) -> Error {
+        unreachable!(); // Testing clock never throws an error.
+    }
+}

beacon_node/src/beacon_chain/block_production.rs

@@ -0,0 +1,75 @@
+use super::{BeaconChain, ClientDB, DBError, SlotClock};
+use slot_clock::TestingSlotClockError;
+use types::{
+    readers::{BeaconBlockReader, BeaconStateReader},
+    BeaconBlock, BeaconState, Hash256,
+};
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    DBError(String),
+    PresentSlotIsNone,
+}
+
+impl<T, U> BeaconChain<T, U>
+where
+    T: ClientDB,
+    U: SlotClock,
+    Error: From<<U as SlotClock>::Error>,
+{
+    pub fn produce_block(&mut self) -> Result<(BeaconBlock, BeaconState), Error> {
+        /*
+         * Important: this code is a big stub and only exists to ensure that tests pass.
+         *
+         * https://github.com/sigp/lighthouse/issues/107
+         */
+        let present_slot = self
+            .slot_clock
+            .present_slot()?
+            .ok_or(Error::PresentSlotIsNone)?;
+        let parent_root = self.canonical_leaf_block;
+        let parent_block_reader = self
+            .block_store
+            .get_reader(&parent_root)?
+            .ok_or_else(|| Error::DBError("Block not found.".to_string()))?;
+        let parent_state_reader = self
+            .state_store
+            .get_reader(&parent_block_reader.state_root())?
+            .ok_or_else(|| Error::DBError("State not found.".to_string()))?;
+
+        let parent_block = parent_block_reader
+            .into_beacon_block()
+            .ok_or_else(|| Error::DBError("Bad parent block SSZ.".to_string()))?;
+        let mut block = BeaconBlock {
+            slot: present_slot,
+            parent_root,
+            state_root: Hash256::zero(), // Updated after the state is calculated.
+            ..parent_block
+        };
+
+        let parent_state = parent_state_reader
+            .into_beacon_state()
+            .ok_or_else(|| Error::DBError("Bad parent block SSZ.".to_string()))?;
+        let state = BeaconState {
+            slot: present_slot,
+            ..parent_state
+        };
+        let state_root = state.canonical_root();
+
+        block.state_root = state_root;
+
+        Ok((block, state))
+    }
+}
+
+impl From<DBError> for Error {
+    fn from(e: DBError) -> Error {
+        Error::DBError(e.message)
+    }
+}
+
+impl From<TestingSlotClockError> for Error {
+    fn from(_: TestingSlotClockError) -> Error {
+        unreachable!(); // Testing clock never throws an error.
+    }
+}

beacon_node/src/beacon_chain/mod.rs

@@ -0,0 +1,81 @@
+mod block_processing;
+mod block_production;
+
+use db::{
+    stores::{BeaconBlockStore, BeaconStateStore},
+    ClientDB, DBError,
+};
+use genesis::{genesis_beacon_block, genesis_beacon_state, GenesisError};
+use slot_clock::SlotClock;
+use spec::ChainSpec;
+use ssz::ssz_encode;
+use std::collections::HashSet;
+use std::sync::Arc;
+use types::Hash256;
+
+pub use crate::block_processing::Outcome as BlockProcessingOutcome;
+
+#[derive(Debug, PartialEq)]
+pub enum BeaconChainError {
+    InsufficientValidators,
+    GenesisError(GenesisError),
+    DBError(String),
+}
+
+pub struct BeaconChain<T: ClientDB + Sized, U: SlotClock> {
+    pub block_store: Arc<BeaconBlockStore<T>>,
+    pub state_store: Arc<BeaconStateStore<T>>,
+    pub slot_clock: U,
+    pub leaf_blocks: HashSet<Hash256>,
+    pub canonical_leaf_block: Hash256,
+    pub spec: ChainSpec,
+}
+
+impl<T, U> BeaconChain<T, U>
+where
+    T: ClientDB,
+    U: SlotClock,
+{
+    pub fn genesis(
+        state_store: Arc<BeaconStateStore<T>>,
+        block_store: Arc<BeaconBlockStore<T>>,
+        slot_clock: U,
+        spec: ChainSpec,
+    ) -> Result<Self, BeaconChainError> {
+        if spec.initial_validators.is_empty() {
+            return Err(BeaconChainError::InsufficientValidators);
+        }
+
+        let genesis_state = genesis_beacon_state(&spec)?;
+        let state_root = genesis_state.canonical_root();
+        state_store.put(&state_root, &ssz_encode(&genesis_state)[..])?;
+
+        let genesis_block = genesis_beacon_block(state_root, &spec);
+        let block_root = genesis_block.canonical_root();
+        block_store.put(&block_root, &ssz_encode(&genesis_block)[..])?;
+
+        let mut leaf_blocks = HashSet::new();
+        leaf_blocks.insert(block_root);
+
+        Ok(Self {
+            block_store,
+            state_store,
+            slot_clock,
+            leaf_blocks,
+            canonical_leaf_block: block_root,
+            spec,
+        })
+    }
+}
+
+impl From<DBError> for BeaconChainError {
+    fn from(e: DBError) -> BeaconChainError {
+        BeaconChainError::DBError(e.message)
+    }
+}
+
+impl From<GenesisError> for BeaconChainError {
+    fn from(e: GenesisError) -> BeaconChainError {
+        BeaconChainError::GenesisError(e)
+    }
+}

beacon_node/src/beacon_chain/tests/chain_test.rs

@@ -0,0 +1,49 @@
+use chain::{BlockProcessingOutcome, BeaconChain};
+use db::{
+    stores::{BeaconBlockStore, BeaconStateStore},
+    MemoryDB,
+};
+use slot_clock::TestingSlotClock;
+use spec::ChainSpec;
+use std::sync::Arc;
+
+fn in_memory_test_stores() -> (
+    Arc<MemoryDB>,
+    Arc<BeaconBlockStore<MemoryDB>>,
+    Arc<BeaconStateStore<MemoryDB>>,
+) {
+    let db = Arc::new(MemoryDB::open());
+    let block_store = Arc::new(BeaconBlockStore::new(db.clone()));
+    let state_store = Arc::new(BeaconStateStore::new(db.clone()));
+    (db, block_store, state_store)
+}
+
+fn in_memory_test_chain(
+    spec: ChainSpec,
+) -> (Arc<MemoryDB>, BeaconChain<MemoryDB, TestingSlotClock>) {
+    let (db, block_store, state_store) = in_memory_test_stores();
+    let slot_clock = TestingSlotClock::new(0);
+
+    let chain = BeaconChain::genesis(state_store, block_store, slot_clock, spec);
+    (db, chain.unwrap())
+}
+
+#[test]
+fn it_constructs() {
+    let (_db, _chain) = in_memory_test_chain(ChainSpec::foundation());
+}
+
+#[test]
+fn it_produces() {
+    let (_db, mut chain) = in_memory_test_chain(ChainSpec::foundation());
+    let (_block, _state) = chain.produce_block().unwrap();
+}
+
+#[test]
+fn it_processes_a_block_it_produces() {
+    let (_db, mut chain) = in_memory_test_chain(ChainSpec::foundation());
+    let (block, _state) = chain.produce_block().unwrap();
+    let (outcome, new_block_hash) = chain.process_block(&block).unwrap();
+    assert_eq!(outcome, BlockProcessingOutcome::Processed);
+    assert_eq!(chain.canonical_leaf_block, new_block_hash);
+}

beacon_node/src/beacon_chain/transition.rs

@@ -0,0 +1,29 @@
+use super::BeaconChain;
+use db::ClientDB;
+use state_transition::{extend_active_state, StateTransitionError};
+use types::{ActiveState, BeaconBlock, CrystallizedState, Hash256};
+
+impl<T, U> BeaconChain<T, U>
+where
+    T: ClientDB + Sized,
+{
+    pub(crate) fn transition_states(
+        &self,
+        act_state: &ActiveState,
+        cry_state: &CrystallizedState,
+        block: &BeaconBlock,
+        block_hash: &Hash256,
+    ) -> Result<(ActiveState, Option<CrystallizedState>), StateTransitionError> {
+        let state_recalc_distance = block
+            .slot
+            .checked_sub(cry_state.last_state_recalculation_slot)
+            .ok_or(StateTransitionError::BlockSlotBeforeRecalcSlot)?;
+
+        if state_recalc_distance >= u64::from(self.spec.epoch_length) {
+            panic!("Not implemented!")
+        } else {
+            let new_act_state = extend_active_state(act_state, block, block_hash)?;
+            Ok((new_act_state, None))
+        }
+    }
+}

beacon_node/src/config/mod.rs

@@ -0,0 +1,30 @@
+use std::fs;
+use std::path::PathBuf;
+
+/// Stores the core configuration for this Lighthouse instance.
+/// This struct is general, other components may implement more
+/// specialized config structs.
+#[derive(Clone)]
+pub struct LighthouseConfig {
+    pub data_dir: PathBuf,
+    pub p2p_listen_port: u16,
+}
+
+const DEFAULT_LIGHTHOUSE_DIR: &str = ".lighthouse";
+
+impl LighthouseConfig {
+    /// Build a new lighthouse configuration from defaults.
+    pub fn default() -> Self {
+        let data_dir = {
+            let home = dirs::home_dir().expect("Unable to determine home dir.");
+            home.join(DEFAULT_LIGHTHOUSE_DIR)
+        };
+        fs::create_dir_all(&data_dir)
+            .unwrap_or_else(|_| panic!("Unable to create {:?}", &data_dir));
+        let p2p_listen_port = 0;
+        Self {
+            data_dir,
+            p2p_listen_port,
+        }
+    }
+}

beacon_node/src/main.rs

@@ -0,0 +1,66 @@
+extern crate slog;
+
+mod config;
+mod rpc;
+
+use std::path::PathBuf;
+
+use crate::config::LighthouseConfig;
+use crate::rpc::start_server;
+use clap::{App, Arg};
+use slog::{error, info, o, Drain};
+
+fn main() {
+    let decorator = slog_term::TermDecorator::new().build();
+    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
+    let drain = slog_async::Async::new(drain).build().fuse();
+    let log = slog::Logger::root(drain, o!());
+
+    let matches = App::new("Lighthouse")
+        .version("0.0.1")
+        .author("Sigma Prime <paul@sigmaprime.io>")
+        .about("Eth 2.0 Client")
+        .arg(
+            Arg::with_name("datadir")
+                .long("datadir")
+                .value_name("DIR")
+                .help("Data directory for keys and databases.")
+                .takes_value(true),
+        )
+        .arg(
+            Arg::with_name("port")
+                .long("port")
+                .value_name("PORT")
+                .help("Network listen port for p2p connections.")
+                .takes_value(true),
+        )
+        .get_matches();
+
+    let mut config = LighthouseConfig::default();
+
+    // Custom datadir
+    if let Some(dir) = matches.value_of("datadir") {
+        config.data_dir = PathBuf::from(dir.to_string());
+    }
+
+    // Custom p2p listen port
+    if let Some(port_str) = matches.value_of("port") {
+        if let Ok(port) = port_str.parse::<u16>() {
+            config.p2p_listen_port = port;
+        } else {
+            error!(log, "Invalid port"; "port" => port_str);
+            return;
+        }
+    }
+
+    // Log configuration
+    info!(log, "";
+          "data_dir" => &config.data_dir.to_str(),
+          "port" => &config.p2p_listen_port);
+
+    let _server = start_server(log.clone());
+
+    loop {}
+
+    // info!(log, "Exiting.");
+}

beacon_node/src/rpc/mod.rs

@@ -0,0 +1,79 @@
+use std::sync::Arc;
+
+use futures::Future;
+use grpcio::{Environment, RpcContext, Server, ServerBuilder, UnarySink};
+
+use protos::services::{
+    BeaconBlock as BeaconBlockProto, ProduceBeaconBlockRequest, ProduceBeaconBlockResponse,
+    PublishBeaconBlockRequest, PublishBeaconBlockResponse,
+};
+use protos::services_grpc::{create_beacon_block_service, BeaconBlockService};
+
+use slog::{info, Logger};
+
+#[derive(Clone)]
+struct BeaconBlockServiceInstance {
+    log: Logger,
+}
+
+impl BeaconBlockService for BeaconBlockServiceInstance {
+    /// Produce a `BeaconBlock` for signing by a validator.
+    fn produce_beacon_block(
+        &mut self,
+        ctx: RpcContext,
+        req: ProduceBeaconBlockRequest,
+        sink: UnarySink<ProduceBeaconBlockResponse>,
+    ) {
+        println!("producing at slot {}", req.get_slot());
+
+        // TODO: build a legit block.
+        let mut block = BeaconBlockProto::new();
+        block.set_slot(req.get_slot());
+        block.set_block_root("cats".as_bytes().to_vec());
+
+        let mut resp = ProduceBeaconBlockResponse::new();
+        resp.set_block(block);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+
+    /// Accept some fully-formed `BeaconBlock`, process and publish it.
+    fn publish_beacon_block(
+        &mut self,
+        ctx: RpcContext,
+        req: PublishBeaconBlockRequest,
+        sink: UnarySink<PublishBeaconBlockResponse>,
+    ) {
+        println!("publishing {:?}", req.get_block());
+
+        // TODO: actually process the block.
+        let mut resp = PublishBeaconBlockResponse::new();
+        resp.set_success(true);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+}
+
+pub fn start_server(log: Logger) -> Server {
+    let log_clone = log.clone();
+
+    let env = Arc::new(Environment::new(1));
+    let instance = BeaconBlockServiceInstance { log };
+    let service = create_beacon_block_service(instance);
+    let mut server = ServerBuilder::new(env)
+        .register_service(service)
+        .bind("127.0.0.1", 50_051)
+        .build()
+        .unwrap();
+    server.start();
+    for &(ref host, port) in server.bind_addrs() {
+        info!(log_clone, "gRPC listening on {}:{}", host, port);
+    }
+    server
+}