Move beacon_chain into lighthouse dir

lighthouse/beacon_chain/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "chain"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+[dependencies]
+bls = { path = "../../beacon_chain/utils/bls" }
+db = { path = "../db" }
+genesis = { path = "../../beacon_chain/genesis" }
+naive_fork_choice = { path = "../../beacon_chain/naive_fork_choice" }
+slot_clock = { path = "../../beacon_chain/utils/slot_clock" }
+spec = { path = "../../beacon_chain/spec" }
+ssz = { path = "../../beacon_chain/utils/ssz" }
+types = { path = "../../beacon_chain/types" }
+validator_induction = { path = "../../beacon_chain/validator_induction" }
+validator_shuffling = { path = "../../beacon_chain/validator_shuffling" }

lighthouse/beacon_chain/src/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.
+    }
+}

lighthouse/beacon_chain/src/block_production.rs

@@ -0,0 +1,64 @@
+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> {
+        let present_slot = self
+            .slot_clock
+            .present_slot()?
+            .ok_or(Error::PresentSlotIsNone)?;
+        let parent_root = self.canonical_leaf_block;
+        let parent_block = self
+            .block_store
+            .get_deserialized(&parent_root)?
+            .ok_or(Error::DBError("Block not found.".to_string()))?;
+        let parent_state = self
+            .state_store
+            .get_deserialized(&parent_block.state_root())?
+            .ok_or(Error::DBError("State not found.".to_string()))?;
+
+        let mut block = BeaconBlock {
+            slot: present_slot,
+            parent_root,
+            state_root: Hash256::zero(), // Updated after the state is calculated.
+            ..parent_block.to_beacon_block()
+        };
+
+        let state = BeaconState {
+            slot: present_slot,
+            ..parent_state.to_beacon_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.
+    }
+}

lighthouse/beacon_chain/src/lib.rs

@@ -0,0 +1,83 @@
+mod block_processing;
+mod block_production;
+mod maps;
+mod stores;
+
+use db::{
+    stores::{BeaconBlockStore, BeaconStateStore},
+    ClientDB, DBError,
+};
+use genesis::{genesis_beacon_block, genesis_beacon_state, GenesisError};
+use slot_clock::{SlotClock, TestingSlotClockError};
+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.clone());
+
+        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)
+    }
+}

lighthouse/beacon_chain/src/maps.rs

@@ -0,0 +1,127 @@
+use types::{AttesterMap, ProposerMap, ShardCommittee};
+
+#[derive(Debug, PartialEq)]
+pub enum AttesterAndProposerMapError {
+    NoShardCommitteeForSlot,
+    NoAvailableProposer,
+}
+
+/// Generate a map of `(slot, shard) |--> committee`.
+///
+/// The attester map is used to optimise the lookup of a committee.
+pub fn generate_attester_and_proposer_maps(
+    shard_and_committee_for_slots: &Vec<Vec<ShardCommittee>>,
+    start_slot: u64,
+) -> Result<(AttesterMap, ProposerMap), AttesterAndProposerMapError> {
+    let mut attester_map = AttesterMap::new();
+    let mut proposer_map = ProposerMap::new();
+    for (i, slot) in shard_and_committee_for_slots.iter().enumerate() {
+        /*
+         * Store the proposer for the block.
+         */
+        let slot_number = (i as u64).saturating_add(start_slot);
+        let first_committee = &slot
+            .get(0)
+            .ok_or(AttesterAndProposerMapError::NoShardCommitteeForSlot)?
+            .committee;
+        let proposer_index = (slot_number as usize)
+            .checked_rem(first_committee.len())
+            .ok_or(AttesterAndProposerMapError::NoAvailableProposer)?;
+        proposer_map.insert(slot_number, first_committee[proposer_index]);
+
+        /*
+         * Loop through the shards and extend the attester map.
+         */
+        for shard_and_committee in slot {
+            let committee = shard_and_committee.committee.clone();
+            attester_map.insert((slot_number, shard_and_committee.shard), committee);
+        }
+    }
+    Ok((attester_map, proposer_map))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sac_generator(
+        shard_count: u64,
+        slot_count: usize,
+        sac_per_slot: usize,
+        committee_size: usize,
+    ) -> Vec<Vec<ShardCommittee>> {
+        let mut shard = 0;
+        let mut validator = 0;
+        let mut cycle = vec![];
+
+        for _ in 0..slot_count {
+            let mut slot: Vec<ShardCommittee> = vec![];
+            for _ in 0..sac_per_slot {
+                let mut sac = ShardCommittee {
+                    shard: shard % shard_count,
+                    committee: vec![],
+                };
+                for _ in 0..committee_size {
+                    sac.committee.push(validator);
+                    validator += 1;
+                }
+                slot.push(sac);
+                shard += 1;
+            }
+            cycle.push(slot);
+        }
+        cycle
+    }
+
+    #[test]
+    fn test_attester_proposer_maps_empty_slots() {
+        let sac = sac_generator(4, 4, 0, 1);
+        let result = generate_attester_and_proposer_maps(&sac, 0);
+        assert_eq!(
+            result,
+            Err(AttesterAndProposerMapError::NoShardCommitteeForSlot)
+        );
+    }
+
+    #[test]
+    fn test_attester_proposer_maps_empty_committees() {
+        let sac = sac_generator(4, 4, 1, 0);
+        let result = generate_attester_and_proposer_maps(&sac, 0);
+        assert_eq!(
+            result,
+            Err(AttesterAndProposerMapError::NoAvailableProposer)
+        );
+    }
+
+    #[test]
+    fn test_attester_proposer_maps_scenario_a() {
+        let sac = sac_generator(4, 4, 1, 1);
+        let (a, p) = generate_attester_and_proposer_maps(&sac, 0).unwrap();
+
+        assert_eq!(*p.get(&0).unwrap(), 0);
+        assert_eq!(*p.get(&1).unwrap(), 1);
+        assert_eq!(*p.get(&2).unwrap(), 2);
+        assert_eq!(*p.get(&3).unwrap(), 3);
+
+        assert_eq!(*a.get(&(0, 0)).unwrap(), vec![0]);
+        assert_eq!(*a.get(&(1, 1)).unwrap(), vec![1]);
+        assert_eq!(*a.get(&(2, 2)).unwrap(), vec![2]);
+        assert_eq!(*a.get(&(3, 3)).unwrap(), vec![3]);
+    }
+
+    #[test]
+    fn test_attester_proposer_maps_scenario_b() {
+        let sac = sac_generator(4, 4, 1, 4);
+        let (a, p) = generate_attester_and_proposer_maps(&sac, 0).unwrap();
+
+        assert_eq!(*p.get(&0).unwrap(), 0);
+        assert_eq!(*p.get(&1).unwrap(), 5);
+        assert_eq!(*p.get(&2).unwrap(), 10);
+        assert_eq!(*p.get(&3).unwrap(), 15);
+
+        assert_eq!(*a.get(&(0, 0)).unwrap(), vec![0, 1, 2, 3]);
+        assert_eq!(*a.get(&(1, 1)).unwrap(), vec![4, 5, 6, 7]);
+        assert_eq!(*a.get(&(2, 2)).unwrap(), vec![8, 9, 10, 11]);
+        assert_eq!(*a.get(&(3, 3)).unwrap(), vec![12, 13, 14, 15]);
+    }
+}

lighthouse/beacon_chain/src/stores.rs

@@ -0,0 +1,9 @@
+use db::stores::{BeaconBlockStore, PoWChainStore, ValidatorStore};
+use db::ClientDB;
+use std::sync::Arc;
+
+pub struct BeaconChainStore<T: ClientDB + Sized> {
+    pub block: Arc<BeaconBlockStore<T>>,
+    pub pow_chain: Arc<PoWChainStore<T>>,
+    pub validator: Arc<ValidatorStore<T>>,
+}

lighthouse/beacon_chain/src/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))
+        }
+    }
+}

lighthouse/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);
+}