Fixes

Author: macladson

beacon_node/beacon_chain/benches/benches.rs

@@ -26,8 +26,11 @@ fn create_test_block_and_blobs<E: EthSpec>(
     let blobs = (0..num_of_blobs)
         .map(|_| Blob::<E>::default())
         .collect::<Vec<_>>()
-        .into();
-    let proofs = vec![KzgProof::empty(); num_of_blobs * E::number_of_columns()].into();
+        .try_into()
+        .unwrap();
+    let proofs = vec![KzgProof::empty(); num_of_blobs * E::number_of_columns()]
+        .try_into()
+        .unwrap();
 
     (signed_block, blobs, proofs)
 }

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -63,7 +63,6 @@ use types::{
     Attestation, AttestationData, AttestationRef, BeaconCommittee,
     BeaconStateError::NoCommitteeFound, ChainSpec, CommitteeIndex, Epoch, EthSpec, Hash256,
     IndexedAttestation, SelectionProof, SignedAggregateAndProof, SingleAttestation, Slot, SubnetId,
-    attestation::Error as AttestationError,
 };
 
 pub use batch::{batch_verify_aggregated_attestations, batch_verify_unaggregated_attestations};
@@ -108,18 +107,14 @@ pub enum Error {
     /// ## Peer scoring
     ///
     /// The peer has sent an invalid message.
-    InvalidSelectionProof {
-        aggregator_index: u64,
-    },
+    InvalidSelectionProof { aggregator_index: u64 },
     /// The `selection_proof` on the aggregate attestation selects it as a validator, however the
     /// aggregator index is not in the committee for that attestation.
     ///
     /// ## Peer scoring
     ///
     /// The peer has sent an invalid message.
-    AggregatorNotInCommittee {
-        aggregator_index: u64,
-    },
+    AggregatorNotInCommittee { aggregator_index: u64 },
     /// The `attester_index` for a `SingleAttestation` is not a member of the committee defined
     /// by its `beacon_block_root`, `committee_index` and `slot`.
     ///
@@ -171,19 +166,15 @@ pub enum Error {
     ///
     /// The attestation points to a block we have not yet imported. It's unclear if the attestation
     /// is valid or not.
-    UnknownHeadBlock {
-        beacon_block_root: Hash256,
-    },
+    UnknownHeadBlock { beacon_block_root: Hash256 },
     /// The `attestation.data.beacon_block_root` block is from before the finalized checkpoint.
     ///
     /// ## Peer scoring
     ///
     /// The attestation is not descended from the finalized checkpoint, which is a REJECT according
     /// to the spec. We downscore lightly because this could also happen if we are processing
     /// attestations extremely slowly.
-    HeadBlockFinalized {
-        beacon_block_root: Hash256,
-    },
+    HeadBlockFinalized { beacon_block_root: Hash256 },
     /// The `attestation.data.slot` is not from the same epoch as `data.target.epoch`.
     ///
     /// ## Peer scoring
@@ -210,10 +201,7 @@ pub enum Error {
     /// ## Peer scoring
     ///
     /// The peer has sent an invalid message.
-    NoCommitteeForSlotAndIndex {
-        slot: Slot,
-        index: CommitteeIndex,
-    },
+    NoCommitteeForSlotAndIndex { slot: Slot, index: CommitteeIndex },
     /// The attestation doesn't have only one aggregation bit set.
     ///
     /// ## Peer scoring
@@ -228,20 +216,14 @@ pub enum Error {
     /// It's unclear if this attestation is valid, however we have already observed a
     /// single-participant attestation from this validator for this epoch and should not observe
     /// another.
-    PriorAttestationKnown {
-        validator_index: u64,
-        epoch: Epoch,
-    },
+    PriorAttestationKnown { validator_index: u64, epoch: Epoch },
     /// The attestation is attesting to a state that is later than itself. (Viz., attesting to the
     /// future).
     ///
     /// ## Peer scoring
     ///
     /// The peer has sent an invalid message.
-    AttestsToFutureBlock {
-        block: Slot,
-        attestation: Slot,
-    },
+    AttestsToFutureBlock { block: Slot, attestation: Slot },
     /// The attestation was received on an invalid attestation subnet.
     ///
     /// ## Peer scoring
@@ -268,10 +250,7 @@ pub enum Error {
     /// ## Peer scoring
     ///
     /// The peer has sent an invalid message.
-    InvalidTargetEpoch {
-        slot: Slot,
-        epoch: Epoch,
-    },
+    InvalidTargetEpoch { slot: Slot, epoch: Epoch },
     /// The attestation references an invalid target block.
     ///
     /// ## Peer scoring
@@ -288,7 +267,6 @@ pub enum Error {
     /// We were unable to process this attestation due to an internal error. It's unclear if the
     /// attestation is valid.
     BeaconChainError(Box<BeaconChainError>),
-    AttestationError(Box<AttestationError>),
 }
 
 impl From<BeaconChainError> for Error {
@@ -464,10 +442,8 @@ fn process_slash_info<T: BeaconChainTypes>(
                     .spec
                     .fork_name_at_slot::<T::EthSpec>(attestation.data.slot);
 
-                match attestation.to_indexed(fork_name) {
-                    Ok(indexed_attestation) => (indexed_attestation, true, err),
-                    Err(e) => return Error::AttestationError(Box::new(e)),
-                }
+                let indexed_attestation = attestation.to_indexed(fork_name);
+                (indexed_attestation, true, err)
             }
             SignatureNotCheckedIndexed(indexed, err) => (indexed, true, err),
             SignatureInvalid(e) => return e,
@@ -956,15 +932,7 @@ impl<'a, T: BeaconChainTypes> IndexedUnaggregatedAttestation<'a, T> {
             .spec
             .fork_name_at_slot::<T::EthSpec>(attestation.data.slot);
 
-        let indexed_attestation = match attestation.to_indexed(fork_name) {
-            Ok(indexed) => indexed,
-            Err(e) => {
-                return Err(SignatureNotCheckedSingle(
-                    attestation,
-                    Error::AttestationError(Box::new(e)),
-                ));
-            }
-        };
+        let indexed_attestation = attestation.to_indexed(fork_name);
 
         let validator_index = match Self::verify_middle_checks(attestation, chain) {
             Ok(t) => t,

beacon_node/beacon_chain/tests/block_verification.rs

@@ -699,7 +699,7 @@ async fn invalid_signature_attester_slashing() {
 
         let attester_slashing = if fork_name.electra_enabled() {
             let indexed_attestation = IndexedAttestationElectra {
-                attesting_indices: vec![0].into(),
+                attesting_indices: vec![0].try_into().unwrap(),
                 data: AttestationData {
                     slot: Slot::new(0),
                     index: 0,
@@ -723,7 +723,7 @@ async fn invalid_signature_attester_slashing() {
             AttesterSlashing::Electra(attester_slashing)
         } else {
             let indexed_attestation = IndexedAttestationBase {
-                attesting_indices: vec![0].into(),
+                attesting_indices: vec![0].try_into().unwrap(),
                 data: AttestationData {
                     slot: Slot::new(0),
                     index: 0,
@@ -890,7 +890,9 @@ async fn invalid_signature_deposit() {
         let harness = get_invalid_sigs_harness(&chain_segment).await;
         let mut snapshots = chain_segment.clone();
         let deposit = Deposit {
-            proof: vec![Hash256::zero(); DEPOSIT_TREE_DEPTH + 1].into(),
+            proof: vec![Hash256::zero(); DEPOSIT_TREE_DEPTH + 1]
+                .try_into()
+                .unwrap(),
             data: DepositData {
                 pubkey: Keypair::random().pk.into(),
                 withdrawal_credentials: Hash256::zero(),
@@ -1262,7 +1264,9 @@ async fn block_gossip_verification() {
         as usize;
 
     if let Ok(kzg_commitments) = block.body_mut().blob_kzg_commitments_mut() {
-        *kzg_commitments = vec![KzgCommitment::empty_for_testing(); kzg_commitments_len + 1].into();
+        *kzg_commitments = vec![KzgCommitment::empty_for_testing(); kzg_commitments_len + 1]
+            .try_into()
+            .unwrap();
         assert!(
             matches!(
                 unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await),

consensus/fork_choice/tests/tests.rs

@@ -753,10 +753,10 @@ async fn invalid_attestation_empty_bitfield() {
             MutationDelay::NoDelay,
             |attestation, _| match attestation {
                 IndexedAttestation::Base(att) => {
-                    att.attesting_indices = vec![].into();
+                    att.attesting_indices = vec![].try_into().unwrap();
                 }
                 IndexedAttestation::Electra(att) => {
-                    att.attesting_indices = vec![].into();
+                    att.attesting_indices = vec![].try_into().unwrap();
                 }
             },
             |result| {

consensus/types/src/attestation.rs

@@ -622,26 +622,23 @@ pub struct SingleAttestation {
 }
 
 impl SingleAttestation {
-    pub fn to_indexed<E: EthSpec>(
-        &self,
-        fork_name: ForkName,
-    ) -> Result<IndexedAttestation<E>, Error> {
+    pub fn to_indexed<E: EthSpec>(&self, fork_name: ForkName) -> IndexedAttestation<E> {
         if fork_name.electra_enabled() {
-            Ok(IndexedAttestation::Electra(IndexedAttestationElectra {
+            IndexedAttestation::Electra(IndexedAttestationElectra {
                 attesting_indices: vec![self.attester_index]
                     .try_into()
-                    .map_err(Error::SszTypesError)?,
+                    .expect("Single index should not exceed MaxValidatorsPerSlot"),
                 data: self.data.clone(),
                 signature: self.signature.clone(),
-            }))
+            })
         } else {
-            Ok(IndexedAttestation::Base(IndexedAttestationBase {
+            IndexedAttestation::Base(IndexedAttestationBase {
                 attesting_indices: vec![self.attester_index]
                     .try_into()
-                    .map_err(Error::SszTypesError)?,
+                    .expect("Single index should not exceed MaxValidatorsPerCommittee"),
                 data: self.data.clone(),
                 signature: self.signature.clone(),
-            }))
+            })
         }
     }
 }

lcli/src/http_sync.rs

@@ -139,8 +139,8 @@ async fn get_block_from_source<T: EthSpec>(
         let block_root = block_from_source.canonical_root();
         let block_contents = SignedBlockContents {
             signed_block: Arc::new(block_from_source),
-            kzg_proofs: kzg_proofs.into(),
-            blobs: blobs.into(),
+            kzg_proofs: kzg_proofs.try_into().unwrap(),
+            blobs: blobs.try_into().unwrap(),
         };
         let publish_block_req = PublishBlockRequest::BlockContents(block_contents);
 

testing/ef_tests/src/cases/ssz_generic.rs

@@ -326,6 +326,6 @@ where
             N::to_usize()
         )))
     } else {
-        Ok(decoded.into())
+        Ok(decoded.try_into().unwrap())
     }
 }