Shard node

Cargo.toml

@@ -1,7 +1,9 @@
 [workspace]
 members = [
 	"eth2/lmd_ghost",
+	"eth2/shard_lmd_ghost",
 	"eth2/operation_pool",
+	"eth2/shard_operation_pool",
 	"eth2/state_processing",
 	"eth2/types",
 	"eth2/utils/bls",
@@ -33,6 +35,11 @@ members = [
     "beacon_node/rpc",
 	"beacon_node/version",
 	"beacon_node/beacon_chain",
+	"shard_node",
+	"shard_node/shard_store",
+	"shard_node/shard_chain",
+	"shard_node/shard_client",
+	"shard_node/rest_api",
 	"tests/ef_tests",
 	"protos",
 	"validator_client",

beacon_node/beacon_chain/Cargo.toml

@@ -20,6 +20,10 @@ serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 slot_clock = { path = "../../eth2/utils/slot_clock" }
+slog = { version = "^2.2.3" , features = ["max_level_trace"] }
+sloggers = { version = "^0.3" }
+slog-term = "^2.4.0"
+slog-async = "^2.3.0"
 eth2_ssz = { path = "../../eth2/utils/ssz" }
 eth2_ssz_derive = { path = "../../eth2/utils/ssz_derive" }
 state_processing = { path = "../../eth2/state_processing" }

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4,10 +4,10 @@ use crate::fork_choice::{Error as ForkChoiceError, ForkChoice};
 use crate::metrics::Metrics;
 use crate::persisted_beacon_chain::{PersistedBeaconChain, BEACON_CHAIN_DB_KEY};
 use lmd_ghost::LmdGhost;
-use log::trace;
 use operation_pool::DepositInsertStatus;
 use operation_pool::{OperationPool, PersistedOperationPool};
 use parking_lot::{RwLock, RwLockReadGuard};
+use slog::{info, Logger};
 use slot_clock::SlotClock;
 use state_processing::per_block_processing::errors::{
     AttestationValidationError, AttesterSlashingValidationError, DepositValidationError,
@@ -83,6 +83,8 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     pub fork_choice: ForkChoice<T>,
     /// Stores metrics about this `BeaconChain`.
     pub metrics: Metrics,
+
+    pub log: Logger,
 }
 
 impl<T: BeaconChainTypes> BeaconChain<T> {
@@ -93,6 +95,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         mut genesis_state: BeaconState<T::EthSpec>,
         genesis_block: BeaconBlock,
         spec: ChainSpec,
+        log: Logger,
     ) -> Result<Self, Error> {
         genesis_state.build_all_caches(&spec)?;
 
@@ -106,6 +109,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let genesis_block_root = genesis_block.block_header().canonical_root();
         store.put(&spec.zero_hash, &genesis_block)?;
 
+        info!(log, "Beacon chain initialized from genesis";
+              "gensis_slot" => genesis_state.slot,
+              "state_root" => format!("{}", state_root),
+              "block_root" => format!("{}", genesis_block_root),
+        );
+
         let canonical_head = RwLock::new(CheckPoint::new(
             genesis_block.clone(),
             genesis_block_root,
@@ -123,13 +132,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             fork_choice: ForkChoice::new(store.clone(), &genesis_block, genesis_block_root),
             metrics: Metrics::new()?,
             store,
+            log,
         })
     }
 
     /// Attempt to load an existing instance from the given `store`.
     pub fn from_store(
         store: Arc<T::Store>,
         spec: ChainSpec,
+        log: Logger,
     ) -> Result<Option<BeaconChain<T>>, Error> {
         let key = Hash256::from_slice(&BEACON_CHAIN_DB_KEY.as_bytes());
         let p: PersistedBeaconChain<T> = match store.get(&key) {
@@ -159,6 +170,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             genesis_block_root: p.genesis_block_root,
             metrics: Metrics::new()?,
             store,
+            log,
         }))
     }
 
@@ -395,10 +407,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         validator_index: usize,
     ) -> Result<Option<(Slot, u64)>, BeaconStateError> {
-        trace!(
-            "BeaconChain::validator_attestion_slot_and_shard: validator_index: {}",
-            validator_index
-        );
         if let Some(attestation_duty) = self
             .state
             .read()
@@ -418,7 +426,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let head_block_root = self.head().beacon_block_root;
         let head_block_slot = self.head().beacon_block.slot;
 
-        self.produce_attestation_data_for_block(shard, head_block_root, head_block_slot, &*state)
+        self.produce_attestation_data_for_block(
+            shard,
+            head_block_root,
+            head_block_slot,
+            Hash256::zero(),
+            &*state,
+        )
     }
 
     /// Produce an `AttestationData` that attests to the chain denoted by `block_root` and `state`.
@@ -430,6 +444,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         shard: u64,
         head_block_root: Hash256,
         head_block_slot: Slot,
+        crosslink_data_root: Hash256,
         state: &BeaconState<T::EthSpec>,
     ) -> Result<AttestationData, Error> {
         // Collect some metrics.
@@ -478,7 +493,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             target_root,
             shard,
             previous_crosslink_root,
-            crosslink_data_root: Hash256::zero(),
+            crosslink_data_root,
         })
     }
 
@@ -796,6 +811,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     new_epoch: new_finalized_epoch,
                 })
             } else {
+                info!(self.log, "Beacon Fork choice produces new head";
+                    "block_root" => format!("{}", &beacon_block_root),
+                    "state_root" => format!("{}", &beacon_state_root),
+                    "slot" => format!("{}", &beacon_block.slot),
+                );
+
                 self.update_canonical_head(CheckPoint {
                     beacon_block: beacon_block,
                     beacon_block_root,
@@ -866,6 +887,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 new_epoch: new_finalized_epoch,
             })
         } else {
+            info!(self.log, "Beacon Finalization Detected";
+                "root" => format!("{}", finalized_block_root),
+                "pruning fork choice from slot" => format!("{}", finalized_block.slot),
+            );
+
             self.fork_choice
                 .process_finalization(&finalized_block, finalized_block_root)?;
 

beacon_node/beacon_chain/src/test_utils.rs

@@ -1,5 +1,6 @@
 use crate::{BeaconChain, BeaconChainTypes, BlockProcessingOutcome};
 use lmd_ghost::LmdGhost;
+use slog::Logger;
 use slot_clock::SlotClock;
 use slot_clock::TestingSlotClock;
 use state_processing::per_slot_processing;
@@ -80,7 +81,7 @@ where
     E: EthSpec,
 {
     /// Instantiate a new harness with `validator_count` initial validators.
-    pub fn new(validator_count: usize) -> Self {
+    pub fn new(validator_count: usize, log: Logger) -> Self {
         let spec = E::default_spec();
 
         let store = Arc::new(MemoryStore::open());
@@ -105,6 +106,7 @@ where
             genesis_state,
             genesis_block,
             spec.clone(),
+            log,
         )
         .expect("Terminate if beacon chain generation fails");
 
@@ -291,6 +293,7 @@ where
                                 cc.shard,
                                 head_block_root,
                                 head_block_slot,
+                                Hash256::zero(),
                                 state,
                             )
                             .expect("should produce attestation data");

beacon_node/client/src/beacon_chain_types.rs

@@ -49,7 +49,9 @@ where
     T: BeaconChainTypes<Store = U, EthSpec = V>,
     T::LmdGhost: LmdGhost<U, V>,
 {
-    if let Ok(Some(beacon_chain)) = BeaconChain::from_store(store.clone(), spec.clone()) {
+    if let Ok(Some(beacon_chain)) =
+        BeaconChain::from_store(store.clone(), spec.clone(), log.clone())
+    {
         info!(
             log,
             "Loaded BeaconChain from store";
@@ -78,7 +80,14 @@ where
 
         // Genesis chain
         //TODO: Handle error correctly
-        BeaconChain::from_genesis(store, slot_clock, genesis_state, genesis_block, spec)
-            .expect("Terminate if beacon chain generation fails")
+        BeaconChain::from_genesis(
+            store,
+            slot_clock,
+            genesis_state,
+            genesis_block,
+            spec,
+            log.clone(),
+        )
+        .expect("Terminate if beacon chain generation fails")
     }
 }

beacon_node/store/src/impls/beacon_state.rs

@@ -2,27 +2,34 @@ use crate::*;
 use ssz::{Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 use std::convert::TryInto;
-use types::beacon_state::{CommitteeCache, CACHED_EPOCHS};
+use types::beacon_state::{CommitteeCache, PeriodCommitteeCache, CACHED_EPOCHS, CACHED_PERIODS};
 
 /// A container for storing `BeaconState` components.
 #[derive(Encode, Decode)]
 struct StorageContainer {
     state_bytes: Vec<u8>,
     committee_caches_bytes: Vec<Vec<u8>>,
+    period_caches_bytes: Vec<Vec<u8>>,
 }
 
 impl StorageContainer {
     /// Create a new instance for storing a `BeaconState`.
     pub fn new<T: EthSpec>(state: &BeaconState<T>) -> Self {
         let mut committee_caches_bytes = vec![];
+        let mut period_caches_bytes = vec![];
 
         for cache in state.committee_caches[..].iter() {
             committee_caches_bytes.push(cache.as_ssz_bytes());
         }
 
+        for cache in state.period_caches[..].iter() {
+            period_caches_bytes.push(cache.as_ssz_bytes());
+        }
+
         Self {
             state_bytes: state.as_ssz_bytes(),
             committee_caches_bytes,
+            period_caches_bytes,
         }
     }
 }
@@ -43,6 +50,16 @@ impl<T: EthSpec> TryInto<BeaconState<T>> for StorageContainer {
             state.committee_caches[i] = CommitteeCache::from_ssz_bytes(bytes)?;
         }
 
+        for i in 0..CACHED_PERIODS {
+            let bytes = &self.period_caches_bytes.get(i).ok_or_else(|| {
+                Error::SszDecodeError(DecodeError::BytesInvalid(
+                    "Insufficient period committees for BeaconState".to_string(),
+                ))
+            })?;
+
+            state.period_caches[i] = PeriodCommitteeCache::from_ssz_bytes(bytes)?;
+        }
+
         Ok(state)
     }
 }

eth2/shard_lmd_ghost/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "shard_lmd_ghost"
+version = "0.1.0"
+authors = ["Age Manning <[email protected]>", "Paul Hauner <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+parking_lot = "0.7"
+shard_store = { path = "../../shard_node/shard_store" }
+eth2_ssz = { path = "../utils/ssz" }
+state_processing = { path = "../state_processing" }
+types = { path = "../types" }
+log = "0.4.6"
+bit-vec = "0.5.0"
+
+[dev-dependencies]
+criterion = "0.2"
+hex = "0.3.2"
+yaml-rust = "0.4.2"
+bls = { path = "../utils/bls" }
+slot_clock = { path = "../utils/slot_clock" }
+env_logger = "0.6.0"

eth2/shard_lmd_ghost/src/lib.rs

@@ -0,0 +1,46 @@
+mod reduced_tree;
+
+use shard_store::Store;
+use std::sync::Arc;
+use types::{Hash256, ShardBlock, ShardSlot, ShardSpec};
+
+pub use reduced_tree::ThreadSafeReducedTree;
+
+pub type Result<T> = std::result::Result<T, String>;
+
+pub trait LmdGhost<S: Store, E: ShardSpec>: Send + Sync {
+    /// Create a new instance, with the given `store` and `finalized_root`.
+    fn new(store: Arc<S>, finalized_block: &ShardBlock, finalized_root: Hash256) -> Self;
+
+    /// Process an attestation message from some validator that attests to some `block_hash`
+    /// representing a block at some `block_slot`.
+    fn process_attestation(
+        &self,
+        validator_index: usize,
+        block_hash: Hash256,
+        block_slot: ShardSlot,
+    ) -> Result<()>;
+
+    /// Process a block that was seen on the network.
+    fn process_block(&self, block: &ShardBlock, block_hash: Hash256) -> Result<()>;
+
+    /// Returns the head of the chain, starting the search at `start_block_root` and moving upwards
+    /// (in block height).
+    fn find_head<F>(
+        &self,
+        start_block_slot: ShardSlot,
+        start_block_root: Hash256,
+        weight: F,
+    ) -> Result<Hash256>
+    where
+        F: Fn(usize) -> Option<u64> + Copy;
+
+    /// Provide an indication that the blockchain has been finalized at the given `finalized_block`.
+    ///
+    /// `finalized_block_root` must be the root of `finalized_block`.
+    fn update_finalized_root(
+        &self,
+        finalized_block: &ShardBlock,
+        finalized_block_root: Hash256,
+    ) -> Result<()>;
+}