Add incomplete progress on fixing test harness

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -253,6 +253,7 @@ where
     /// Information is read from the present `beacon_state` shuffling, so only information from the
     /// present and prior epoch is available.
     pub fn block_proposer(&self, slot: Slot) -> Result<usize, BeaconStateError> {
+        trace!("BeaconChain::block_proposer: slot: {}", slot);
         let index = self
             .state
             .read()
@@ -274,6 +275,10 @@ where
         &self,
         validator_index: usize,
     ) -> Result<Option<(Slot, u64)>, BeaconStateError> {
+        trace!(
+            "BeaconChain::validator_attestion_slot_and_shard: validator_index: {}",
+            validator_index
+        );
         if let Some((slot, shard, _committee)) = self
             .state
             .read()
@@ -287,6 +292,7 @@ where
 
     /// Produce an `AttestationData` that is valid for the present `slot` and given `shard`.
     pub fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, Error> {
+        trace!("BeaconChain::produce_attestation_data: shard: {}", shard);
         let justified_epoch = self.justified_epoch();
         let justified_block_root = *self
             .state

beacon_node/beacon_chain/src/cached_beacon_state.rs

@@ -0,0 +1,49 @@
+use types::{beacon_state::BeaconStateError, BeaconState, ChainSpec, Epoch, Slot};
+
+pub const CACHED_EPOCHS: usize = 3; // previous, current, next.
+
+pub type CrosslinkCommittees = Vec<(Vec<usize>, u64)>;
+
+pub struct CachedBeaconState<'a> {
+    state: BeaconState,
+    crosslinks: Vec<Vec<CrosslinkCommittees>>,
+    spec: &'a ChainSpec,
+}
+
+impl<'a> CachedBeaconState<'a> {
+    pub fn from_beacon_state(
+        state: BeaconState,
+        spec: &'a ChainSpec,
+    ) -> Result<Self, BeaconStateError> {
+        let current_epoch = state.current_epoch(spec);
+        let previous_epoch = if current_epoch == spec.genesis_epoch {
+            current_epoch
+        } else {
+            current_epoch.saturating_sub(1_u64)
+        };
+        let next_epoch = state.next_epoch(spec);
+
+        let mut crosslinks: Vec<Vec<CrosslinkCommittees>> = Vec::with_capacity(3);
+        crosslinks.push(committees_for_all_slots(&state, previous_epoch, spec)?);
+        crosslinks.push(committees_for_all_slots(&state, current_epoch, spec)?);
+        crosslinks.push(committees_for_all_slots(&state, next_epoch, spec)?);
+
+        Ok(Self {
+            state,
+            crosslinks,
+            spec,
+        })
+    }
+}
+
+fn committees_for_all_slots(
+    state: &BeaconState,
+    epoch: Epoch,
+    spec: &ChainSpec,
+) -> Result<Vec<CrosslinkCommittees>, BeaconStateError> {
+    let mut crosslinks: Vec<CrosslinkCommittees> = Vec::with_capacity(spec.epoch_length as usize);
+    for slot in epoch.slot_iter(spec.epoch_length) {
+        crosslinks.push(state.get_crosslink_committees_at_slot(slot, false, spec)?)
+    }
+    Ok(crosslinks)
+}

beacon_node/beacon_chain/src/lib.rs

@@ -1,5 +1,6 @@
 mod attestation_aggregator;
 mod beacon_chain;
+mod cached_beacon_state;
 mod checkpoint;
 
 pub use self::beacon_chain::{BeaconChain, Error};

beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs

@@ -209,6 +209,7 @@ impl BeaconChainHarness {
         self.increment_beacon_chain_slot();
 
         // Produce a new block.
+        debug!("Producing block...");
         let block = self.produce_block();
         debug!("Submitting block for processing...");
         self.beacon_chain.process_block(block).unwrap();

beacon_node/beacon_chain/test_harness/tests/chain.rs

@@ -1,19 +1,14 @@
 use env_logger::{Builder, Env};
 use log::debug;
 use test_harness::BeaconChainHarness;
-use types::{ChainSpec, Slot};
+use types::ChainSpec;
 
 #[test]
-#[ignore]
 fn it_can_build_on_genesis_block() {
-    let mut spec = ChainSpec::foundation();
-    spec.genesis_slot = Slot::new(spec.epoch_length * 8);
+    Builder::from_env(Env::default().default_filter_or("trace")).init();
+    let spec = ChainSpec::few_validators();
 
-    /*
-    spec.shard_count = spec.shard_count / 8;
-    spec.target_committee_size = spec.target_committee_size / 8;
-    */
-    let validator_count = 1000;
+    let validator_count = 8;
 
     let mut harness = BeaconChainHarness::new(spec, validator_count as usize);
 
@@ -23,7 +18,7 @@ fn it_can_build_on_genesis_block() {
 #[test]
 #[ignore]
 fn it_can_produce_past_first_epoch_boundary() {
-    Builder::from_env(Env::default().default_filter_or("debug")).init();
+    Builder::from_env(Env::default().default_filter_or("trace")).init();
 
     let validator_count = 100;
 
@@ -33,7 +28,7 @@ fn it_can_produce_past_first_epoch_boundary() {
 
     debug!("Harness built, tests starting..");
 
-    let blocks = harness.spec.epoch_length * 3 + 1;
+    let blocks = harness.spec.epoch_length * 2 + 1;
 
     for i in 0..blocks {
         harness.advance_chain_with_block();