Merge remote-tracking branch 'origin/master' into v0.9

eth2/state_processing/src/per_block_processing/block_processing_builder.rs

@@ -1,5 +1,9 @@
+use std::convert::TryInto;
 use tree_hash::SignedRoot;
-use types::test_utils::{TestingBeaconBlockBuilder, TestingBeaconStateBuilder};
+use types::test_utils::{
+    AttestationTestTask, AttesterSlashingTestTask, DepositTestTask, ExitTestTask,
+    ProposerSlashingTestTask, TestingBeaconBlockBuilder, TestingBeaconStateBuilder,
+};
 use types::*;
 
 pub struct BlockProcessingBuilder<T: EthSpec> {
@@ -30,6 +34,242 @@ impl<T: EthSpec> BlockProcessingBuilder<T> {
         self.state_builder.build_caches(&spec).unwrap();
     }
 
+    pub fn build_with_n_deposits(
+        mut self,
+        num_deposits: u64,
+        test_task: DepositTestTask,
+        randao_sk: Option<SecretKey>,
+        previous_block_root: Option<Hash256>,
+        spec: &ChainSpec,
+    ) -> (BeaconBlock<T>, BeaconState<T>) {
+        let (mut state, keypairs) = self.state_builder.build();
+
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        match previous_block_root {
+            Some(root) => builder.set_parent_root(root),
+            None => builder.set_parent_root(Hash256::from_slice(
+                &state.latest_block_header.signed_root(),
+            )),
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        match randao_sk {
+            Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
+            None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
+        }
+
+        self.block_builder.insert_deposits(
+            spec.max_effective_balance,
+            test_task,
+            1,
+            num_deposits,
+            &mut state,
+            spec,
+        );
+
+        let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        (block, state)
+    }
+
+    pub fn build_with_n_exits(
+        mut self,
+        num_exits: usize,
+        test_task: ExitTestTask,
+        randao_sk: Option<SecretKey>,
+        previous_block_root: Option<Hash256>,
+        spec: &ChainSpec,
+    ) -> (BeaconBlock<T>, BeaconState<T>) {
+        let (mut state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        match previous_block_root {
+            Some(root) => builder.set_parent_root(root),
+            None => builder.set_parent_root(Hash256::from_slice(
+                &state.latest_block_header.signed_root(),
+            )),
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        match randao_sk {
+            Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
+            None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
+        }
+        match test_task {
+            ExitTestTask::AlreadyInitiated => {
+                for _ in 0..2 {
+                    self.block_builder.insert_exit(
+                        test_task,
+                        &mut state,
+                        (0 as usize).try_into().unwrap(),
+                        &keypairs[0].sk,
+                        spec,
+                    )
+                }
+            }
+            _ => {
+                for (i, keypair) in keypairs.iter().take(num_exits).enumerate() {
+                    self.block_builder.insert_exit(
+                        test_task,
+                        &mut state,
+                        (i as usize).try_into().unwrap(),
+                        &keypair.sk,
+                        spec,
+                    );
+                }
+            }
+        }
+
+        let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        (block, state)
+    }
+
+    pub fn build_with_n_attestations(
+        mut self,
+        test_task: AttestationTestTask,
+        num_attestations: u64,
+        randao_sk: Option<SecretKey>,
+        previous_block_root: Option<Hash256>,
+        spec: &ChainSpec,
+    ) -> (BeaconBlock<T>, BeaconState<T>) {
+        let (state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        match previous_block_root {
+            Some(root) => builder.set_parent_root(root),
+            None => builder.set_parent_root(Hash256::from_slice(
+                &state.latest_block_header.signed_root(),
+            )),
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        match randao_sk {
+            Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
+            None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
+        }
+
+        let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
+        self.block_builder
+            .insert_attestations(
+                test_task,
+                &state,
+                &all_secret_keys,
+                num_attestations as usize,
+                spec,
+            )
+            .unwrap();
+        let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        (block, state)
+    }
+
+    pub fn build_with_attester_slashing(
+        mut self,
+        test_task: AttesterSlashingTestTask,
+        num_attester_slashings: u64,
+        randao_sk: Option<SecretKey>,
+        previous_block_root: Option<Hash256>,
+        spec: &ChainSpec,
+    ) -> (BeaconBlock<T>, BeaconState<T>) {
+        let (state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        match previous_block_root {
+            Some(root) => builder.set_parent_root(root),
+            None => builder.set_parent_root(Hash256::from_slice(
+                &state.latest_block_header.signed_root(),
+            )),
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        match randao_sk {
+            Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
+            None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
+        }
+
+        let mut validator_indices = vec![];
+        let mut secret_keys = vec![];
+        for i in 0..num_attester_slashings {
+            validator_indices.push(i);
+            secret_keys.push(&keypairs[i as usize].sk);
+        }
+
+        for _ in 0..num_attester_slashings {
+            self.block_builder.insert_attester_slashing(
+                test_task,
+                &validator_indices,
+                &secret_keys,
+                &state.fork,
+                spec,
+            );
+        }
+        let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        (block, state)
+    }
+
+    pub fn build_with_proposer_slashing(
+        mut self,
+        test_task: ProposerSlashingTestTask,
+        num_proposer_slashings: u64,
+        randao_sk: Option<SecretKey>,
+        previous_block_root: Option<Hash256>,
+        spec: &ChainSpec,
+    ) -> (BeaconBlock<T>, BeaconState<T>) {
+        let (state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        match previous_block_root {
+            Some(root) => builder.set_parent_root(root),
+            None => builder.set_parent_root(Hash256::from_slice(
+                &state.latest_block_header.signed_root(),
+            )),
+        }
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        match randao_sk {
+            Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
+            None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
+        }
+
+        for i in 0..num_proposer_slashings {
+            let validator_indices = i;
+            let secret_keys = &keypairs[i as usize].sk;
+            self.block_builder.insert_proposer_slashing(
+                test_task,
+                validator_indices,
+                &secret_keys,
+                &state.fork,
+                spec,
+            );
+        }
+        let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        (block, state)
+    }
+
     pub fn build(
         mut self,
         randao_sk: Option<SecretKey>,

eth2/state_processing/src/per_block_processing/errors.rs

@@ -181,8 +181,6 @@ pub enum ProposerSlashingInvalid {
 
 #[derive(Debug, PartialEq)]
 pub enum AttesterSlashingInvalid {
-    /// The attestation data is identical, an attestation cannot conflict with itself.
-    AttestationDataIdentical,
     /// The attestations were not in conflict.
     NotSlashable,
     /// The first `IndexedAttestation` was invalid.
@@ -222,23 +220,14 @@ pub enum AttestationInvalid {
         attestation: Checkpoint,
         is_current: bool,
     },
-    /// The custody bitfield has some bits set `true`. This is not allowed in phase 0.
-    CustodyBitfieldHasSetBits,
     /// There are no set bits on the attestation -- an attestation must be signed by at least one
     /// validator.
     AggregationBitfieldIsEmpty,
-    /// The custody bitfield length is not the smallest possible size to represent the committee.
-    BadCustodyBitfieldLength {
-        committee_len: usize,
-        bitfield_len: usize,
-    },
     /// The aggregation bitfield length is not the smallest possible size to represent the committee.
     BadAggregationBitfieldLength {
         committee_len: usize,
         bitfield_len: usize,
     },
-    /// The bits set in the custody bitfield are not a subset of those set in the aggregation bits.
-    CustodyBitfieldNotSubset,
     /// The validator index was unknown.
     UnknownValidator(u64),
     /// The attestation signature verification failed.
@@ -264,14 +253,6 @@ impl From<BlockOperationError<IndexedAttestationInvalid>>
 
 #[derive(Debug, PartialEq)]
 pub enum IndexedAttestationInvalid {
-    /// The custody bit 0 validators intersect with the bit 1 validators.
-    CustodyBitValidatorsIntersect,
-    /// The custody bitfield has some bits set `true`. This is not allowed in phase 0.
-    CustodyBitfieldHasSetBits,
-    /// The custody bitfield violated a type-level bound.
-    CustodyBitfieldBoundsError(ssz_types::Error),
-    /// No validator indices were specified.
-    NoValidatorIndices,
     /// The number of indices exceeds the global maximum.
     ///
     /// (max_indices, indices_given)
@@ -291,8 +272,6 @@ pub enum IndexedAttestationInvalid {
 
 #[derive(Debug, PartialEq)]
 pub enum DepositInvalid {
-    /// The deposit index does not match the state index.
-    BadIndex { state: u64, deposit: u64 },
     /// The signature (proof-of-possession) does not match the given pubkey.
     BadSignature,
     /// The signature or pubkey does not represent a valid BLS point.
@@ -311,7 +290,7 @@ pub enum ExitInvalid {
     /// The specified validator has a non-maximum exit epoch.
     AlreadyExited(u64),
     /// The specified validator has already initiated exit.
-    AlreadyInitiatedExited(u64),
+    AlreadyInitiatedExit(u64),
     /// The exit is for a future epoch.
     FutureEpoch { state: Epoch, exit: Epoch },
     /// The validator has not been active for long enough.

eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs

@@ -29,7 +29,8 @@ pub fn is_valid_indexed_attestation<T: EthSpec>(
     // Check that indices are sorted
     let check_sorted = |list: &[u64]| -> Result<()> {
         list.windows(2).enumerate().try_for_each(|(i, pair)| {
-            if pair[0] >= pair[1] {
+            // The spec allows duplicates, so use strict comparison (>).
+            if pair[0] > pair[1] {
                 Err(error(Invalid::BadValidatorIndicesOrdering(i)))
             } else {
                 Ok(())

eth2/state_processing/src/per_block_processing/signature_sets.rs

@@ -7,7 +7,7 @@ use std::convert::TryInto;
 use tree_hash::{SignedRoot, TreeHash};
 use types::{
     AggregateSignature, AttesterSlashing, BeaconBlock, BeaconBlockHeader, BeaconState,
-    BeaconStateError, ChainSpec, Deposit, Domain, EthSpec, Fork, Hash256, IndexedAttestation,
+    BeaconStateError, ChainSpec, DepositData, Domain, EthSpec, Hash256, IndexedAttestation,
     ProposerSlashing, PublicKey, Signature, VoluntaryExit,
 };
 
@@ -180,18 +180,17 @@ pub fn attester_slashing_signature_sets<'a, T: EthSpec>(
 ///
 /// This method is separate to `deposit_signature_set` to satisfy lifetime requirements.
 pub fn deposit_pubkey_signature_message(
-    deposit: &Deposit,
+    deposit_data: &DepositData,
 ) -> Option<(PublicKey, Signature, Vec<u8>)> {
-    let pubkey = (&deposit.data.pubkey).try_into().ok()?;
-    let signature = (&deposit.data.signature).try_into().ok()?;
-    let message = deposit.data.signed_root();
+    let pubkey = (&deposit_data.pubkey).try_into().ok()?;
+    let signature = (&deposit_data.signature).try_into().ok()?;
+    let message = deposit_data.signed_root();
     Some((pubkey, signature, message))
 }
 
 /// Returns the signature set for some set of deposit signatures, made with
 /// `deposit_pubkey_signature_message`.
-pub fn deposit_signature_set<'a, T: EthSpec>(
-    state: &'a BeaconState<T>,
+pub fn deposit_signature_set<'a>(
     pubkey_signature_message: &'a (PublicKey, Signature, Vec<u8>),
     spec: &'a ChainSpec,
 ) -> SignatureSet<'a> {
@@ -199,9 +198,12 @@ pub fn deposit_signature_set<'a, T: EthSpec>(
 
     // Note: Deposits are valid across forks, thus the deposit domain is computed
     // with the fork zeroed.
-    let domain = spec.get_domain(state.current_epoch(), Domain::Deposit, &Fork::default());
-
-    SignatureSet::single(signature, pubkey, message.clone(), domain)
+    SignatureSet::single(
+        signature,
+        pubkey,
+        message.clone(),
+        spec.get_deposit_domain(),
+    )
 }
 
 /// Returns a signature set that is valid if the `VoluntaryExit` was signed by the indicated

eth2/state_processing/src/per_block_processing/verify_attestation.rs

@@ -57,6 +57,7 @@ pub fn verify_attestation_for_state<T: EthSpec>(
     spec: &ChainSpec,
 ) -> Result<()> {
     let data = &attestation.data;
+
     verify!(
         data.index < state.get_committee_count_at_slot(data.slot)?,
         Invalid::BadCommitteeIndex

eth2/state_processing/src/per_block_processing/verify_deposit.rs

@@ -15,16 +15,12 @@ fn error(reason: DepositInvalid) -> BlockOperationError<DepositInvalid> {
 /// Verify `Deposit.pubkey` signed `Deposit.signature`.
 ///
 /// Spec v0.9.1
-pub fn verify_deposit_signature<T: EthSpec>(
-    state: &BeaconState<T>,
-    deposit: &Deposit,
-    spec: &ChainSpec,
-) -> Result<()> {
-    let deposit_signature_message = deposit_pubkey_signature_message(deposit)
+pub fn verify_deposit_signature(deposit_data: &DepositData, spec: &ChainSpec) -> Result<()> {
+    let deposit_signature_message = deposit_pubkey_signature_message(&deposit_data)
         .ok_or_else(|| error(DepositInvalid::BadBlsBytes))?;
 
     verify!(
-        deposit_signature_set(state, &deposit_signature_message, spec).is_valid(),
+        deposit_signature_set(&deposit_signature_message, spec).is_valid(),
         DepositInvalid::BadSignature
     );