Implement ConsensusContext

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -70,7 +70,7 @@ use state_processing::{
     per_block_processing::{errors::AttestationValidationError, is_merge_transition_complete},
     per_slot_processing,
     state_advance::{complete_state_advance, partial_state_advance},
-    BlockSignatureStrategy, SigVerifiedOp, VerifyBlockRoot,
+    BlockSignatureStrategy, ConsensusContext, SigVerifiedOp, VerifyBlockRoot,
 };
 use std::borrow::Cow;
 use std::cmp::Ordering;
@@ -3096,12 +3096,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
 
         let process_timer = metrics::start_timer(&metrics::BLOCK_PRODUCTION_PROCESS_TIMES);
+        let mut ctxt = ConsensusContext::new(block.slot()).set_proposer_index(proposer_index);
         per_block_processing(
             &mut state,
             &block,
-            None,
             BlockSignatureStrategy::VerifyRandao,
             VerifyBlockRoot::True,
+            &mut ctxt,
             &self.spec,
         )?;
         drop(process_timer);

beacon_node/beacon_chain/src/block_verification.rs

@@ -63,7 +63,8 @@ use state_processing::{
     block_signature_verifier::{BlockSignatureVerifier, Error as BlockSignatureVerifierError},
     per_block_processing, per_slot_processing,
     state_advance::partial_state_advance,
-    BlockProcessingError, BlockSignatureStrategy, SlotProcessingError, VerifyBlockRoot,
+    BlockProcessingError, BlockSignatureStrategy, ConsensusContext, SlotProcessingError,
+    VerifyBlockRoot,
 };
 use std::borrow::Cow;
 use std::fs;
@@ -488,10 +489,16 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
 
     let mut signature_verified_blocks = chain_segment
         .into_iter()
-        .map(|(block_root, block)| SignatureVerifiedBlock {
+        .map(|(block_root, block)| {
-            block,
+            // FIXME(sproul): safe to include proposer index here?
-            block_root,
+            let consensus_context =
-            parent: None,
+                ConsensusContext::new(block.slot()).set_current_block_root(block_root);
+            SignatureVerifiedBlock {
+                block,
+                block_root,
+                parent: None,
+                consensus_context,
+            }
         })
         .collect::<Vec<_>>();
 
@@ -509,6 +516,7 @@ pub struct GossipVerifiedBlock<T: BeaconChainTypes> {
     pub block: SignedBeaconBlock<T::EthSpec>,
     pub block_root: Hash256,
     parent: Option<PreProcessingSnapshot<T::EthSpec>>,
+    consensus_context: ConsensusContext<T::EthSpec>,
 }
 
 /// A wrapper around a `SignedBeaconBlock` that indicates that all signatures (except the deposit
@@ -517,6 +525,7 @@ pub struct SignatureVerifiedBlock<T: BeaconChainTypes> {
     block: SignedBeaconBlock<T::EthSpec>,
     block_root: Hash256,
     parent: Option<PreProcessingSnapshot<T::EthSpec>>,
+    consensus_context: ConsensusContext<T::EthSpec>,
 }
 
 /// A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and
@@ -780,10 +789,16 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         // Validate the block's execution_payload (if any).
         validate_execution_payload_for_gossip(&parent_block, block.message(), chain)?;
 
+        // Having checked the proposer index and the block root we can cache them.
+        let consensus_context = ConsensusContext::new(block.slot())
+            .set_current_block_root(block_root)
+            .set_proposer_index(block.message().proposer_index());
+
         Ok(Self {
             block,
             block_root,
             parent,
+            consensus_context,
         })
     }
 
@@ -846,6 +861,8 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
 
         if signature_verifier.verify().is_ok() {
             Ok(Self {
+                consensus_context: ConsensusContext::new(block.slot())
+                    .set_current_block_root(block_root),
                 block,
                 block_root,
                 parent: Some(parent),
@@ -895,6 +912,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
                 block,
                 block_root: from.block_root,
                 parent: Some(parent),
+                consensus_context: from.consensus_context,
             })
         } else {
             Err(BlockError::InvalidSignature)
@@ -930,6 +948,7 @@ impl<T: BeaconChainTypes> IntoFullyVerifiedBlock<T> for SignatureVerifiedBlock<T
             block,
             self.block_root,
             parent,
+            self.consensus_context,
             chain,
         )
         .map_err(|e| BlockSlashInfo::SignatureValid(header, e))
@@ -972,6 +991,7 @@ impl<'a, T: BeaconChainTypes> FullyVerifiedBlock<'a, T> {
         block: SignedBeaconBlock<T::EthSpec>,
         block_root: Hash256,
         parent: PreProcessingSnapshot<T::EthSpec>,
+        mut consensus_context: ConsensusContext<T::EthSpec>,
         chain: &BeaconChain<T>,
     ) -> Result<Self, BlockError<T::EthSpec>> {
         // Reject any block if its parent is not known to fork choice.
@@ -1172,10 +1192,10 @@ impl<'a, T: BeaconChainTypes> FullyVerifiedBlock<'a, T> {
         if let Err(err) = per_block_processing(
             &mut state,
             &block,
-            Some(block_root),
             // Signatures were verified earlier in this function.
             BlockSignatureStrategy::NoVerification,
             VerifyBlockRoot::True,
+            &mut consensus_context,
             &chain.spec,
         ) {
             match err {

beacon_node/beacon_chain/src/fork_revert.rs

@@ -4,7 +4,8 @@ use itertools::process_results;
 use slog::{info, warn, Logger};
 use state_processing::state_advance::complete_state_advance;
 use state_processing::{
-    per_block_processing, per_block_processing::BlockSignatureStrategy, VerifyBlockRoot,
+    per_block_processing, per_block_processing::BlockSignatureStrategy, ConsensusContext,
+    VerifyBlockRoot,
 };
 use std::sync::Arc;
 use std::time::Duration;
@@ -158,12 +159,14 @@ pub fn reset_fork_choice_to_finalization<E: EthSpec, Hot: ItemStore<E>, Cold: It
         complete_state_advance(&mut state, None, block.slot(), spec)
             .map_err(|e| format!("State advance failed: {:?}", e))?;
 
+        let mut ctxt = ConsensusContext::new(block.slot())
+            .set_proposer_index(block.message().proposer_index());
         per_block_processing(
             &mut state,
             &block,
-            None,
             BlockSignatureStrategy::NoVerification,
             VerifyBlockRoot::True,
+            &mut ctxt,
             spec,
         )
         .map_err(|e| format!("Error replaying block: {:?}", e))?;

beacon_node/store/src/reconstruct.rs

@@ -4,7 +4,8 @@ use crate::{Error, ItemStore, KeyValueStore};
 use itertools::{process_results, Itertools};
 use slog::info;
 use state_processing::{
-    per_block_processing, per_slot_processing, BlockSignatureStrategy, VerifyBlockRoot,
+    per_block_processing, per_slot_processing, BlockSignatureStrategy, ConsensusContext,
+    VerifyBlockRoot,
 };
 use std::sync::Arc;
 use types::{EthSpec, Hash256};
@@ -87,12 +88,16 @@ where
 
                 // Apply block.
                 if let Some(block) = block {
+                    let mut ctxt = ConsensusContext::new(block.slot())
+                        .set_current_block_root(block_root)
+                        .set_proposer_index(block.message().proposer_index());
+
                     per_block_processing(
                         &mut state,
                         &block,
-                        Some(block_root),
                         BlockSignatureStrategy::NoVerification,
                         VerifyBlockRoot::True,
+                        &mut ctxt,
                         &self.spec,
                     )
                     .map_err(HotColdDBError::BlockReplayBlockError)?;

consensus/state_processing/src/block_replayer.rs

@@ -1,6 +1,7 @@
 use crate::{
     per_block_processing, per_epoch_processing::EpochProcessingSummary, per_slot_processing,
-    BlockProcessingError, BlockSignatureStrategy, SlotProcessingError, VerifyBlockRoot,
+    BlockProcessingError, BlockSignatureStrategy, ConsensusContext, SlotProcessingError,
+    VerifyBlockRoot,
 };
 use std::marker::PhantomData;
 use types::{BeaconState, ChainSpec, EthSpec, Hash256, SignedBeaconBlock, Slot};
@@ -226,12 +227,13 @@ where
                     VerifyBlockRoot::False
                 }
             });
+            let mut ctxt = ConsensusContext::new(block.slot());
             per_block_processing(
                 &mut self.state,
                 block,
-                None,
                 self.block_sig_strategy,
                 verify_block_root,
+                &mut ctxt,
                 self.spec,
             )
             .map_err(BlockReplayError::from)?;

consensus/state_processing/src/consensus_context.rs

@@ -0,0 +1,89 @@
+use std::marker::PhantomData;
+use tree_hash::TreeHash;
+use types::{BeaconState, BeaconStateError, ChainSpec, EthSpec, Hash256, SignedBeaconBlock, Slot};
+
+#[derive(Debug)]
+pub struct ConsensusContext<T: EthSpec> {
+    /// Slot to act as an identifier/safeguard
+    slot: Slot,
+    /// Proposer index of the block at `slot`.
+    proposer_index: Option<u64>,
+    /// Block root of the block at `slot`.
+    current_block_root: Option<Hash256>,
+    _phantom: PhantomData<T>,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum ContextError {
+    BeaconState(BeaconStateError),
+    SlotMismatch { slot: Slot, expected: Slot },
+}
+
+impl From<BeaconStateError> for ContextError {
+    fn from(e: BeaconStateError) -> Self {
+        Self::BeaconState(e)
+    }
+}
+
+impl<T: EthSpec> ConsensusContext<T> {
+    pub fn new(slot: Slot) -> Self {
+        Self {
+            slot,
+            proposer_index: None,
+            current_block_root: None,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn set_proposer_index(mut self, proposer_index: u64) -> Self {
+        self.proposer_index = Some(proposer_index);
+        self
+    }
+
+    pub fn get_proposer_index(
+        &mut self,
+        state: &BeaconState<T>,
+        spec: &ChainSpec,
+    ) -> Result<u64, ContextError> {
+        self.check_slot(state.slot())?;
+
+        if let Some(proposer_index) = self.proposer_index {
+            return Ok(proposer_index);
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(self.slot, spec)? as u64;
+        self.proposer_index = Some(proposer_index);
+        Ok(proposer_index)
+    }
+
+    pub fn set_current_block_root(mut self, block_root: Hash256) -> Self {
+        self.current_block_root = Some(block_root);
+        self
+    }
+
+    pub fn get_current_block_root(
+        &mut self,
+        block: &SignedBeaconBlock<T>,
+    ) -> Result<Hash256, ContextError> {
+        self.check_slot(block.slot())?;
+
+        if let Some(current_block_root) = self.current_block_root {
+            return Ok(current_block_root);
+        }
+
+        let current_block_root = block.tree_hash_root();
+        self.current_block_root = Some(current_block_root);
+        Ok(current_block_root)
+    }
+
+    fn check_slot(&self, slot: Slot) -> Result<(), ContextError> {
+        if slot == self.slot {
+            Ok(())
+        } else {
+            Err(ContextError::SlotMismatch {
+                slot,
+                expected: self.slot,
+            })
+        }
+    }
+}

consensus/state_processing/src/lib.rs

@@ -18,6 +18,7 @@ mod metrics;
 
 pub mod block_replayer;
 pub mod common;
+pub mod consensus_context;
 pub mod genesis;
 pub mod per_block_processing;
 pub mod per_epoch_processing;
@@ -27,6 +28,7 @@ pub mod upgrade;
 pub mod verify_operation;
 
 pub use block_replayer::{BlockReplayError, BlockReplayer};
+pub use consensus_context::{ConsensusContext, ContextError};
 pub use genesis::{
     eth2_genesis_time, initialize_beacon_state_from_eth1, is_valid_genesis_state,
     process_activations,

consensus/state_processing/src/per_block_processing.rs

@@ -1,3 +1,4 @@
+use crate::consensus_context::ConsensusContext;
 use errors::{BlockOperationError, BlockProcessingError, HeaderInvalid};
 use rayon::prelude::*;
 use safe_arith::{ArithError, SafeArith};
@@ -90,9 +91,9 @@ pub enum VerifyBlockRoot {
 pub fn per_block_processing<T: EthSpec>(
     state: &mut BeaconState<T>,
     signed_block: &SignedBeaconBlock<T>,
-    block_root: Option<Hash256>,
     block_signature_strategy: BlockSignatureStrategy,
     verify_block_root: VerifyBlockRoot,
+    ctxt: &mut ConsensusContext<T>,
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
     let block = signed_block.message();
@@ -110,6 +111,7 @@ pub fn per_block_processing<T: EthSpec>(
     let verify_signatures = match block_signature_strategy {
         BlockSignatureStrategy::VerifyBulk => {
             // Verify all signatures in the block at once.
+            let block_root = Some(ctxt.get_current_block_root(signed_block)?);
             block_verify!(
                 BlockSignatureVerifier::verify_entire_block(
                     state,
@@ -129,10 +131,10 @@ pub fn per_block_processing<T: EthSpec>(
         BlockSignatureStrategy::VerifyRandao => VerifySignatures::False,
     };
 
-    let proposer_index = process_block_header(state, block, verify_block_root, spec)?;
+    let proposer_index = process_block_header(state, block, verify_block_root, ctxt, spec)?;
 
     if verify_signatures.is_true() {
-        verify_block_signature(state, signed_block, block_root, spec)?;
+        verify_block_signature(state, signed_block, ctxt, spec)?;
     }
 
     let verify_randao = if let BlockSignatureStrategy::VerifyRandao = block_signature_strategy {
@@ -174,6 +176,7 @@ pub fn process_block_header<T: EthSpec>(
     state: &mut BeaconState<T>,
     block: BeaconBlockRef<'_, T>,
     verify_block_root: VerifyBlockRoot,
+    ctxt: &mut ConsensusContext<T>,
     spec: &ChainSpec,
 ) -> Result<u64, BlockOperationError<HeaderInvalid>> {
     // Verify that the slots match
@@ -192,8 +195,8 @@ pub fn process_block_header<T: EthSpec>(
     );
 
     // Verify that proposer index is the correct index
-    let proposer_index = block.proposer_index() as usize;
+    let proposer_index = block.proposer_index();
-    let state_proposer_index = state.get_beacon_proposer_index(block.slot(), spec)?;
+    let state_proposer_index = ctxt.get_proposer_index(state, spec)?;
     verify!(
         proposer_index == state_proposer_index,
         HeaderInvalid::ProposerIndexMismatch {
@@ -217,11 +220,11 @@ pub fn process_block_header<T: EthSpec>(
 
     // Verify proposer is not slashed
     verify!(
-        !state.get_validator(proposer_index)?.slashed,
+        !state.get_validator(proposer_index as usize)?.slashed,
         HeaderInvalid::ProposerSlashed(proposer_index)
     );
 
-    Ok(block.proposer_index())
+    Ok(proposer_index)
 }
 
 /// Verifies the signature of a block.
@@ -230,9 +233,10 @@ pub fn process_block_header<T: EthSpec>(
 pub fn verify_block_signature<T: EthSpec>(
     state: &BeaconState<T>,
     block: &SignedBeaconBlock<T>,
-    block_root: Option<Hash256>,
+    ctxt: &mut ConsensusContext<T>,
     spec: &ChainSpec,
 ) -> Result<(), BlockOperationError<HeaderInvalid>> {
+    let block_root = Some(ctxt.get_current_block_root(block)?);
     verify!(
         block_proposal_signature_set(
             state,

consensus/state_processing/src/per_block_processing/errors.rs

@@ -1,4 +1,5 @@
 use super::signature_sets::Error as SignatureSetError;
+use crate::ContextError;
 use merkle_proof::MerkleTreeError;
 use safe_arith::ArithError;
 use types::*;
@@ -70,6 +71,7 @@ pub enum BlockProcessingError {
         found: u64,
     },
     ExecutionInvalid,
+    ConsensusContext(ContextError),
     #[cfg(feature = "milhouse")]
     MilhouseError(milhouse::Error),
 }
@@ -104,6 +106,12 @@ impl From<SyncAggregateInvalid> for BlockProcessingError {
     }
 }
 
+impl From<ContextError> for BlockProcessingError {
+    fn from(e: ContextError) -> Self {
+        BlockProcessingError::ConsensusContext(e)
+    }
+}
+
 #[cfg(feature = "milhouse")]
 impl From<milhouse::Error> for BlockProcessingError {
     fn from(e: milhouse::Error) -> Self {
@@ -118,6 +126,7 @@ impl From<BlockOperationError<HeaderInvalid>> for BlockProcessingError {
             BlockOperationError::BeaconStateError(e) => BlockProcessingError::BeaconStateError(e),
             BlockOperationError::SignatureSetError(e) => BlockProcessingError::SignatureSetError(e),
             BlockOperationError::SszTypesError(e) => BlockProcessingError::SszTypesError(e),
+            BlockOperationError::ConsensusContext(e) => BlockProcessingError::ConsensusContext(e),
             BlockOperationError::ArithError(e) => BlockProcessingError::ArithError(e),
         }
     }
@@ -145,6 +154,7 @@ macro_rules! impl_into_block_processing_error_with_index {
                         BlockOperationError::BeaconStateError(e) => BlockProcessingError::BeaconStateError(e),
                         BlockOperationError::SignatureSetError(e) => BlockProcessingError::SignatureSetError(e),
                         BlockOperationError::SszTypesError(e) => BlockProcessingError::SszTypesError(e),
+                        BlockOperationError::ConsensusContext(e) => BlockProcessingError::ConsensusContext(e),
                         BlockOperationError::ArithError(e) => BlockProcessingError::ArithError(e),
                     }
                 }
@@ -176,6 +186,7 @@ pub enum BlockOperationError<T> {
     BeaconStateError(BeaconStateError),
     SignatureSetError(SignatureSetError),
     SszTypesError(ssz_types::Error),
+    ConsensusContext(ContextError),
     ArithError(ArithError),
 }
 
@@ -208,6 +219,12 @@ impl<T> From<ArithError> for BlockOperationError<T> {
     }
 }
 
+impl<T> From<ContextError> for BlockOperationError<T> {
+    fn from(e: ContextError) -> Self {
+        BlockOperationError::ConsensusContext(e)
+    }
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub enum HeaderInvalid {
     ProposalSignatureInvalid,
@@ -217,14 +234,14 @@ pub enum HeaderInvalid {
         block_slot: Slot,
     },
     ProposerIndexMismatch {
-        block_proposer_index: usize,
+        block_proposer_index: u64,
-        state_proposer_index: usize,
+        state_proposer_index: u64,
     },
     ParentBlockRootMismatch {
         state: Hash256,
         block: Hash256,
     },
-    ProposerSlashed(usize),
+    ProposerSlashed(u64),
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -319,6 +336,7 @@ impl From<BlockOperationError<IndexedAttestationInvalid>>
             BlockOperationError::BeaconStateError(e) => BlockOperationError::BeaconStateError(e),
             BlockOperationError::SignatureSetError(e) => BlockOperationError::SignatureSetError(e),
             BlockOperationError::SszTypesError(e) => BlockOperationError::SszTypesError(e),
+            BlockOperationError::ConsensusContext(e) => BlockOperationError::ConsensusContext(e),
             BlockOperationError::ArithError(e) => BlockOperationError::ArithError(e),
         }
     }

lcli/src/transition_blocks.rs

@@ -98,7 +98,7 @@ fn do_transition<T: EthSpec>(
         &mut pre_state,
         &block,
         None,
-        BlockSignatureStrategy::VerifyBulk,
+        BlockSignatureStrategy::NoVerification,
         VerifyBlockRoot::True,
         spec,
     )