Check attestation shuffling when producing blocks (#900)

Closes #845

eth2/operation_pool/src/lib.rs

@@ -98,10 +98,14 @@ impl<T: EthSpec> OperationPool<T> {
 
     /// Get a list of attestations for inclusion in a block.
     ///
-    /// NOTE: Assumes that all attestations in the operation_pool are valid.
+    /// The `validity_filter` is a closure that provides extra filtering of the attestations
+    /// before an approximately optimal bundle is constructed. We use it to provide access
+    /// to the fork choice data from the `BeaconChain` struct that doesn't logically belong
+    /// in the operation pool.
     pub fn get_attestations(
         &self,
         state: &BeaconState<T>,
+        validity_filter: impl FnMut(&&Attestation<T>) -> bool,
         spec: &ChainSpec,
     ) -> Result<Vec<Attestation<T>>, OpPoolError> {
         // Attestations for the current fork, which may be from the current or previous epoch.
@@ -143,6 +147,7 @@ impl<T: EthSpec> OperationPool<T> {
                 )
                 .is_ok()
             })
+            .filter(validity_filter)
             .flat_map(|att| AttMaxCover::new(att, state, total_active_balance, spec));
 
         Ok(maximum_cover(
@@ -584,7 +589,7 @@ mod release_tests {
         state.slot -= 1;
         assert_eq!(
             op_pool
-                .get_attestations(state, spec)
+                .get_attestations(state, |_| true, spec)
                 .expect("should have attestations")
                 .len(),
             0
@@ -594,7 +599,7 @@ mod release_tests {
         state.slot += spec.min_attestation_inclusion_delay;
 
         let block_attestations = op_pool
-            .get_attestations(state, spec)
+            .get_attestations(state, |_| true, spec)
             .expect("Should have block attestations");
         assert_eq!(block_attestations.len(), committees.len());
 
@@ -764,7 +769,7 @@ mod release_tests {
 
         state.slot += spec.min_attestation_inclusion_delay;
         let best_attestations = op_pool
-            .get_attestations(state, spec)
+            .get_attestations(state, |_| true, spec)
             .expect("should have best attestations");
         assert_eq!(best_attestations.len(), max_attestations);
 
@@ -839,7 +844,7 @@ mod release_tests {
 
         state.slot += spec.min_attestation_inclusion_delay;
         let best_attestations = op_pool
-            .get_attestations(state, spec)
+            .get_attestations(state, |_| true, spec)
             .expect("should have valid best attestations");
         assert_eq!(best_attestations.len(), max_attestations);
 

eth2/proto_array_fork_choice/src/proto_array.rs

@@ -407,4 +407,41 @@ impl ProtoArray {
             && (node.finalized_epoch == self.finalized_epoch
                 || self.finalized_epoch == Epoch::new(0))
     }
+
+    /// Return a reverse iterator over the nodes which comprise the chain ending at `block_root`.
+    pub fn iter_nodes<'a>(&'a self, block_root: &Hash256) -> Iter<'a> {
+        let next_node_index = self.indices.get(block_root).copied();
+        Iter {
+            next_node_index,
+            proto_array: self,
+        }
+    }
+
+    /// Return a reverse iterator over the block roots of the chain ending at `block_root`.
+    ///
+    /// Note that unlike many other iterators, this one WILL NOT yield anything at skipped slots.
+    pub fn iter_block_roots<'a>(
+        &'a self,
+        block_root: &Hash256,
+    ) -> impl Iterator<Item = (Hash256, Slot)> + 'a {
+        self.iter_nodes(block_root)
+            .map(|node| (node.root, node.slot))
+    }
+}
+
+/// Reverse iterator over one path through a `ProtoArray`.
+pub struct Iter<'a> {
+    next_node_index: Option<usize>,
+    proto_array: &'a ProtoArray,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a ProtoNode;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next_node_index = self.next_node_index?;
+        let node = self.proto_array.nodes.get(next_node_index)?;
+        self.next_node_index = node.parent;
+        Some(node)
+    }
 }