Update to v0.9.1

eth2/state_processing/src/per_block_processing/is_valid_indexed_attestation.rs

@@ -1,8 +1,6 @@
 use super::errors::{BlockOperationError, IndexedAttestationInvalid as Invalid};
 use super::signature_sets::indexed_attestation_signature_set;
 use crate::VerifySignatures;
-use std::collections::HashSet;
-use std::iter::FromIterator;
 use types::*;
 
 type Result<T> = std::result::Result<T, BlockOperationError<Invalid>>;
@@ -20,28 +18,15 @@ pub fn is_valid_indexed_attestation<T: EthSpec>(
     verify_signatures: VerifySignatures,
     spec: &ChainSpec,
 ) -> Result<()> {
-    let bit_0_indices = &indexed_attestation.custody_bit_0_indices;
-    let bit_1_indices = &indexed_attestation.custody_bit_1_indices;
-
-    // Verify no index has custody bit equal to 1 [to be removed in phase 1]
-    verify!(bit_1_indices.is_empty(), Invalid::CustodyBitfieldHasSetBits);
+    let indices = &indexed_attestation.attesting_indices;
 
     // Verify max number of indices
-    let total_indices = bit_0_indices.len() + bit_1_indices.len();
     verify!(
-        total_indices <= T::MaxValidatorsPerCommittee::to_usize(),
-        Invalid::MaxIndicesExceed(T::MaxValidatorsPerCommittee::to_usize(), total_indices)
+        indices.len() <= T::MaxValidatorsPerCommittee::to_usize(),
+        Invalid::MaxIndicesExceed(T::MaxValidatorsPerCommittee::to_usize(), indices.len())
     );
 
-    // Verify index sets are disjoint
-    let custody_bit_intersection: HashSet<&u64> =
-        &HashSet::from_iter(bit_0_indices.iter()) & &HashSet::from_iter(bit_1_indices.iter());
-    verify!(
-        custody_bit_intersection.is_empty(),
-        Invalid::CustodyBitValidatorsIntersect
-    );
-
-    // Check that both vectors of indices are sorted
+    // 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] {
@@ -52,8 +37,7 @@ pub fn is_valid_indexed_attestation<T: EthSpec>(
         })?;
         Ok(())
     };
-    check_sorted(&bit_0_indices)?;
-    check_sorted(&bit_1_indices)?;
+    check_sorted(indices)?;
 
     if verify_signatures.is_true() {
         verify!(

eth2/state_processing/src/per_block_processing/signature_sets.rs

@@ -2,13 +2,13 @@
 //! validated individually, or alongside in others in a potentially cheaper bulk operation.
 //!
 //! This module exposes one function to extract each type of `SignatureSet` from a `BeaconBlock`.
-use bls::SignatureSet;
+use bls::{SignatureSet, SignedMessage};
 use std::convert::TryInto;
 use tree_hash::{SignedRoot, TreeHash};
 use types::{
-    AggregateSignature, AttestationDataAndCustodyBit, AttesterSlashing, BeaconBlock,
-    BeaconBlockHeader, BeaconState, BeaconStateError, ChainSpec, Deposit, Domain, EthSpec, Fork,
-    Hash256, IndexedAttestation, ProposerSlashing, PublicKey, Signature, VoluntaryExit,
+    AggregateSignature, AttesterSlashing, BeaconBlock, BeaconBlockHeader, BeaconState,
+    BeaconStateError, ChainSpec, Deposit, Domain, EthSpec, Fork, Hash256, IndexedAttestation,
+    ProposerSlashing, PublicKey, Signature, VoluntaryExit,
 };
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -138,16 +138,12 @@ pub fn indexed_attestation_signature_set<'a, 'b, T: EthSpec>(
     indexed_attestation: &'b IndexedAttestation<T>,
     spec: &'a ChainSpec,
 ) -> Result<SignatureSet<'a>> {
-    let message_0 = AttestationDataAndCustodyBit {
-        data: indexed_attestation.data.clone(),
-        custody_bit: false,
-    }
-    .tree_hash_root();
-    let message_1 = AttestationDataAndCustodyBit {
-        data: indexed_attestation.data.clone(),
-        custody_bit: true,
-    }
-    .tree_hash_root();
+    let message = indexed_attestation.data.tree_hash_root();
+
+    let signed_message = SignedMessage::new(
+        get_pubkeys(state, &indexed_attestation.attesting_indices)?,
+        message,
+    );
 
     let domain = spec.get_domain(
         indexed_attestation.data.target.epoch,
@@ -155,14 +151,7 @@ pub fn indexed_attestation_signature_set<'a, 'b, T: EthSpec>(
         &state.fork,
     );
 
-    Ok(SignatureSet::dual(
-        signature,
-        message_0,
-        get_pubkeys(state, &indexed_attestation.custody_bit_0_indices)?,
-        message_1,
-        get_pubkeys(state, &indexed_attestation.custody_bit_1_indices)?,
-        domain,
-    ))
+    Ok(SignatureSet::new(signature, vec![signed_message], domain))
 }
 
 /// Returns the signature set for the given `attester_slashing` and corresponding `pubkeys`.

eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs

@@ -71,15 +71,13 @@ where
     let attestation_2 = &attester_slashing.attestation_2;
 
     let attesting_indices_1 = attestation_1
-        .custody_bit_0_indices
+        .attesting_indices
         .iter()
-        .chain(&attestation_1.custody_bit_1_indices)
         .cloned()
         .collect::<BTreeSet<_>>();
     let attesting_indices_2 = attestation_2
-        .custody_bit_0_indices
+        .attesting_indices
         .iter()
-        .chain(&attestation_2.custody_bit_1_indices)
         .cloned()
         .collect::<BTreeSet<_>>();