merged master

eth2/state_processing/src/per_block_processing/errors.rs

@@ -67,7 +67,10 @@ impl_from_beacon_state_error!(BlockProcessingError);
 #[derive(Debug, PartialEq)]
 pub enum BlockInvalid {
     StateSlotMismatch,
-    ParentBlockRootMismatch,
+    ParentBlockRootMismatch {
+        state: Hash256,
+        block: Hash256,
+    },
     BadSignature,
     BadRandaoSignature,
     MaxAttestationsExceeded,
@@ -271,10 +274,10 @@ pub enum ProposerSlashingValidationError {
 pub enum ProposerSlashingInvalid {
     /// The proposer index is not a known validator.
     ProposerUnknown(u64),
-    /// The two proposal have different slots.
+    /// The two proposal have different epochs.
     ///
     /// (proposal_1_slot, proposal_2_slot)
-    ProposalSlotMismatch(Slot, Slot),
+    ProposalEpochMismatch(Slot, Slot),
     /// The proposals are identical and therefore not slashable.
     ProposalsIdentical,
     /// The specified proposer has already been slashed.

eth2/state_processing/src/per_block_processing/validate_attestation.rs

@@ -1,6 +1,6 @@
 use super::errors::{AttestationInvalid as Invalid, AttestationValidationError as Error};
 use crate::common::verify_bitfield_length;
-use ssz::TreeHash;
+use tree_hash::TreeHash;
 use types::*;
 
 /// Indicates if an `Attestation` is valid to be included in a block in the current epoch of the
@@ -8,9 +8,9 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn validate_attestation(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn validate_attestation<T: EthSpec>(
+    state: &BeaconState<T>,
     attestation: &Attestation,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -18,8 +18,8 @@ pub fn validate_attestation(
 }
 
 /// Like `validate_attestation` but doesn't run checks which may become true in future states.
-pub fn validate_attestation_time_independent_only(
-    state: &BeaconState,
+pub fn validate_attestation_time_independent_only<T: EthSpec>(
+    state: &BeaconState<T>,
     attestation: &Attestation,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -31,9 +31,9 @@ pub fn validate_attestation_time_independent_only(
 ///
 /// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn validate_attestation_without_signature(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn validate_attestation_without_signature<T: EthSpec>(
+    state: &BeaconState<T>,
     attestation: &Attestation,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -44,9 +44,9 @@ pub fn validate_attestation_without_signature(
 /// given state, optionally validating the aggregate signature.
 ///
 ///
-/// Spec v0.5.0
-fn validate_attestation_parametric(
-    state: &BeaconState,
+/// Spec v0.5.1
+fn validate_attestation_parametric<T: EthSpec>(
+    state: &BeaconState<T>,
     attestation: &Attestation,
     spec: &ChainSpec,
     verify_signature: bool,
@@ -167,10 +167,10 @@ fn validate_attestation_parametric(
 /// Verify that the `source_epoch` and `source_root` of an `Attestation` correctly
 /// match the current (or previous) justified epoch and root from the state.
 ///
-/// Spec v0.5.0
-fn verify_justified_epoch_and_root(
+/// Spec v0.5.1
+fn verify_justified_epoch_and_root<T: EthSpec>(
     attestation: &Attestation,
-    state: &BeaconState,
+    state: &BeaconState<T>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let state_epoch = state.slot.epoch(spec.slots_per_epoch);
@@ -222,9 +222,9 @@ fn verify_justified_epoch_and_root(
 ///  - `custody_bitfield` does not have a bit for each index of `committee`.
 ///  - A `validator_index` in `committee` is not in `state.validator_registry`.
 ///
-/// Spec v0.5.0
-fn verify_attestation_signature(
-    state: &BeaconState,
+/// Spec v0.5.1
+fn verify_attestation_signature<T: EthSpec>(
+    state: &BeaconState<T>,
     committee: &[usize],
     a: &Attestation,
     spec: &ChainSpec,
@@ -270,14 +270,14 @@ fn verify_attestation_signature(
         data: a.data.clone(),
         custody_bit: false,
     }
-    .hash_tree_root();
+    .tree_hash_root();
 
     // Message when custody bitfield is `true`
     let message_1 = AttestationDataAndCustodyBit {
         data: a.data.clone(),
         custody_bit: true,
     }
-    .hash_tree_root();
+    .tree_hash_root();
 
     let mut messages = vec![];
     let mut keys = vec![];

eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs

@@ -7,9 +7,9 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `AttesterSlashing` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn verify_attester_slashing(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn verify_attester_slashing<T: EthSpec>(
+    state: &BeaconState<T>,
     attester_slashing: &AttesterSlashing,
     should_verify_slashable_attestations: bool,
     spec: &ChainSpec,
@@ -41,9 +41,9 @@ pub fn verify_attester_slashing(
 ///
 /// Returns Ok(indices) if `indices.len() > 0`.
 ///
-/// Spec v0.5.0
-pub fn gather_attester_slashing_indices(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn gather_attester_slashing_indices<T: EthSpec>(
+    state: &BeaconState<T>,
     attester_slashing: &AttesterSlashing,
     spec: &ChainSpec,
 ) -> Result<Vec<u64>, Error> {
@@ -57,8 +57,8 @@ pub fn gather_attester_slashing_indices(
 
 /// Same as `gather_attester_slashing_indices` but allows the caller to specify the criteria
 /// for determining whether a given validator should be considered slashed.
-pub fn gather_attester_slashing_indices_modular<F>(
-    state: &BeaconState,
+pub fn gather_attester_slashing_indices_modular<F, T: EthSpec>(
+    state: &BeaconState<T>,
     attester_slashing: &AttesterSlashing,
     is_slashed: F,
     spec: &ChainSpec,

eth2/state_processing/src/per_block_processing/verify_deposit.rs

@@ -15,9 +15,9 @@ use types::*;
 ///
 /// Note: this function is incomplete.
 ///
-/// Spec v0.5.0
-pub fn verify_deposit(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn verify_deposit<T: EthSpec>(
+    state: &BeaconState<T>,
     deposit: &Deposit,
     verify_merkle_branch: bool,
     spec: &ChainSpec,
@@ -46,8 +46,11 @@ pub fn verify_deposit(
 
 /// Verify that the `Deposit` index is correct.
 ///
-/// Spec v0.5.0
-pub fn verify_deposit_index(state: &BeaconState, deposit: &Deposit) -> Result<(), Error> {
+/// Spec v0.5.1
+pub fn verify_deposit_index<T: EthSpec>(
+    state: &BeaconState<T>,
+    deposit: &Deposit,
+) -> Result<(), Error> {
     verify!(
         deposit.index == state.deposit_index,
         Invalid::BadIndex {
@@ -65,8 +68,8 @@ pub fn verify_deposit_index(state: &BeaconState, deposit: &Deposit) -> Result<()
 /// ## Errors
 ///
 /// Errors if the state's `pubkey_cache` is not current.
-pub fn get_existing_validator_index(
-    state: &BeaconState,
+pub fn get_existing_validator_index<T: EthSpec>(
+    state: &BeaconState<T>,
     deposit: &Deposit,
 ) -> Result<Option<u64>, Error> {
     let deposit_input = &deposit.deposit_data.deposit_input;
@@ -88,12 +91,16 @@ pub fn get_existing_validator_index(
 
 /// Verify that a deposit is included in the state's eth1 deposit root.
 ///
-/// Spec v0.5.0
-fn verify_deposit_merkle_proof(state: &BeaconState, deposit: &Deposit, spec: &ChainSpec) -> bool {
+/// Spec v0.5.1
+fn verify_deposit_merkle_proof<T: EthSpec>(
+    state: &BeaconState<T>,
+    deposit: &Deposit,
+    spec: &ChainSpec,
+) -> bool {
     let leaf = hash(&get_serialized_deposit_data(deposit));
     verify_merkle_proof(
         Hash256::from_slice(&leaf),
-        &deposit.proof,
+        &deposit.proof[..],
         spec.deposit_contract_tree_depth as usize,
         deposit.index as usize,
         state.latest_eth1_data.deposit_root,
@@ -102,7 +109,7 @@ fn verify_deposit_merkle_proof(state: &BeaconState, deposit: &Deposit, spec: &Ch
 
 /// Helper struct for easily getting the serialized data generated by the deposit contract.
 ///
-/// Spec v0.5.0
+/// Spec v0.5.1
 #[derive(Encode)]
 struct SerializedDepositData {
     amount: u64,
@@ -113,7 +120,7 @@ struct SerializedDepositData {
 /// Return the serialized data generated by the deposit contract that is used to generate the
 /// merkle proof.
 ///
-/// Spec v0.5.0
+/// Spec v0.5.1
 fn get_serialized_deposit_data(deposit: &Deposit) -> Vec<u8> {
     let serialized_deposit_data = SerializedDepositData {
         amount: deposit.deposit_data.amount,

eth2/state_processing/src/per_block_processing/verify_exit.rs

@@ -1,5 +1,5 @@
 use super::errors::{ExitInvalid as Invalid, ExitValidationError as Error};
-use ssz::SignedRoot;
+use tree_hash::SignedRoot;
 use types::*;
 
 /// Indicates if an `Exit` is valid to be included in a block in the current epoch of the given
@@ -7,9 +7,9 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `Exit` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn verify_exit(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn verify_exit<T: EthSpec>(
+    state: &BeaconState<T>,
     exit: &VoluntaryExit,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -17,8 +17,8 @@ pub fn verify_exit(
 }
 
 /// Like `verify_exit` but doesn't run checks which may become true in future states.
-pub fn verify_exit_time_independent_only(
-    state: &BeaconState,
+pub fn verify_exit_time_independent_only<T: EthSpec>(
+    state: &BeaconState<T>,
     exit: &VoluntaryExit,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -26,8 +26,8 @@ pub fn verify_exit_time_independent_only(
 }
 
 /// Parametric version of `verify_exit` that skips some checks if `time_independent_only` is true.
-fn verify_exit_parametric(
-    state: &BeaconState,
+fn verify_exit_parametric<T: EthSpec>(
+    state: &BeaconState<T>,
     exit: &VoluntaryExit,
     spec: &ChainSpec,
     time_independent_only: bool,

eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs

@@ -1,5 +1,5 @@
 use super::errors::{ProposerSlashingInvalid as Invalid, ProposerSlashingValidationError as Error};
-use ssz::SignedRoot;
+use tree_hash::SignedRoot;
 use types::*;
 
 /// Indicates if a `ProposerSlashing` is valid to be included in a block in the current epoch of the given
@@ -7,10 +7,10 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `ProposerSlashing` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn verify_proposer_slashing(
+/// Spec v0.5.1
+pub fn verify_proposer_slashing<T: EthSpec>(
     proposer_slashing: &ProposerSlashing,
-    state: &BeaconState,
+    state: &BeaconState<T>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let proposer = state
@@ -21,8 +21,9 @@ pub fn verify_proposer_slashing(
         })?;
 
     verify!(
-        proposer_slashing.header_1.slot == proposer_slashing.header_2.slot,
-        Invalid::ProposalSlotMismatch(
+        proposer_slashing.header_1.slot.epoch(spec.slots_per_epoch)
+            == proposer_slashing.header_2.slot.epoch(spec.slots_per_epoch),
+        Invalid::ProposalEpochMismatch(
             proposer_slashing.header_1.slot,
             proposer_slashing.header_2.slot
         )
@@ -66,7 +67,7 @@ pub fn verify_proposer_slashing(
 ///
 /// Returns `true` if the signature is valid.
 ///
-/// Spec v0.5.0
+/// Spec v0.5.1
 fn verify_header_signature(
     header: &BeaconBlockHeader,
     pubkey: &PublicKey,

eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs

@@ -2,7 +2,7 @@ use super::errors::{
     SlashableAttestationInvalid as Invalid, SlashableAttestationValidationError as Error,
 };
 use crate::common::verify_bitfield_length;
-use ssz::TreeHash;
+use tree_hash::TreeHash;
 use types::*;
 
 /// Indicates if a `SlashableAttestation` is valid to be included in a block in the current epoch of the given
@@ -10,9 +10,9 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `SlashableAttestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.5.0
-pub fn verify_slashable_attestation(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn verify_slashable_attestation<T: EthSpec>(
+    state: &BeaconState<T>,
     slashable_attestation: &SlashableAttestation,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -77,12 +77,12 @@ pub fn verify_slashable_attestation(
         data: slashable_attestation.data.clone(),
         custody_bit: false,
     }
-    .hash_tree_root();
+    .tree_hash_root();
     let message_1 = AttestationDataAndCustodyBit {
         data: slashable_attestation.data.clone(),
         custody_bit: true,
     }
-    .hash_tree_root();
+    .tree_hash_root();
 
     let mut messages = vec![];
     let mut keys = vec![];

eth2/state_processing/src/per_block_processing/verify_transfer.rs

@@ -1,6 +1,6 @@
 use super::errors::{TransferInvalid as Invalid, TransferValidationError as Error};
 use bls::get_withdrawal_credentials;
-use ssz::SignedRoot;
+use tree_hash::SignedRoot;
 use types::*;
 
 /// Indicates if a `Transfer` is valid to be included in a block in the current epoch of the given
@@ -10,9 +10,9 @@ use types::*;
 ///
 /// Note: this function is incomplete.
 ///
-/// Spec v0.5.0
-pub fn verify_transfer(
-    state: &BeaconState,
+/// Spec v0.5.1
+pub fn verify_transfer<T: EthSpec>(
+    state: &BeaconState<T>,
     transfer: &Transfer,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -20,8 +20,8 @@ pub fn verify_transfer(
 }
 
 /// Like `verify_transfer` but doesn't run checks which may become true in future states.
-pub fn verify_transfer_time_independent_only(
-    state: &BeaconState,
+pub fn verify_transfer_time_independent_only<T: EthSpec>(
+    state: &BeaconState<T>,
     transfer: &Transfer,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
@@ -29,8 +29,8 @@ pub fn verify_transfer_time_independent_only(
 }
 
 /// Parametric version of `verify_transfer` that allows some checks to be skipped.
-fn verify_transfer_parametric(
-    state: &BeaconState,
+fn verify_transfer_parametric<T: EthSpec>(
+    state: &BeaconState<T>,
     transfer: &Transfer,
     spec: &ChainSpec,
     time_independent_only: bool,
@@ -122,9 +122,9 @@ fn verify_transfer_parametric(
 ///
 /// Does not check that the transfer is valid, however checks for overflow in all actions.
 ///
-/// Spec v0.5.0
-pub fn execute_transfer(
-    state: &mut BeaconState,
+/// Spec v0.5.1
+pub fn execute_transfer<T: EthSpec>(
+    state: &mut BeaconState<T>,
     transfer: &Transfer,
     spec: &ChainSpec,
 ) -> Result<(), Error> {