Update Rust Edition to 2024 (#7766)

* #7749

Thanks @dknopik and @michaelsproul for your help!

consensus/proto_array/src/lib.rs

@@ -6,7 +6,7 @@ mod proto_array_fork_choice;
 mod ssz_container;
 
 pub use crate::justified_balances::JustifiedBalances;
-pub use crate::proto_array::{calculate_committee_fraction, InvalidationOperation};
+pub use crate::proto_array::{InvalidationOperation, calculate_committee_fraction};
 pub use crate::proto_array_fork_choice::{
     Block, DisallowedReOrgOffsets, DoNotReOrg, ExecutionStatus, ProposerHeadError,
     ProposerHeadInfo, ProtoArrayForkChoice, ReOrgThreshold,

consensus/proto_array/src/proto_array.rs

@@ -1,8 +1,8 @@
 use crate::error::InvalidBestNodeInfo;
-use crate::{error::Error, Block, ExecutionStatus, JustifiedBalances};
+use crate::{Block, ExecutionStatus, JustifiedBalances, error::Error};
 use serde::{Deserialize, Serialize};
-use ssz::four_byte_option_impl;
 use ssz::Encode;
+use ssz::four_byte_option_impl;
 use ssz_derive::{Decode, Encode};
 use std::collections::{HashMap, HashSet};
 use superstruct::superstruct;
@@ -223,21 +223,18 @@ impl ProtoArray {
             // the delta by the new score amount (unless the block has an invalid execution status).
             //
             // https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#get_latest_attesting_balance
-            if let Some(proposer_score_boost) = spec.proposer_score_boost {
-                if proposer_boost_root != Hash256::zero()
+            if let Some(proposer_score_boost) = spec.proposer_score_boost
+                && proposer_boost_root != Hash256::zero()
                     && proposer_boost_root == node.root
                     // Invalid nodes (or their ancestors) should not receive a proposer boost.
                     && !execution_status_is_invalid
-                {
-                    proposer_score = calculate_committee_fraction::<E>(
-                        new_justified_balances,
-                        proposer_score_boost,
-                    )
-                    .ok_or(Error::ProposerBoostOverflow(node_index))?;
-                    node_delta = node_delta
-                        .checked_add(proposer_score as i64)
-                        .ok_or(Error::DeltaOverflow(node_index))?;
-                }
+            {
+                proposer_score =
+                    calculate_committee_fraction::<E>(new_justified_balances, proposer_score_boost)
+                        .ok_or(Error::ProposerBoostOverflow(node_index))?;
+                node_delta = node_delta
+                    .checked_add(proposer_score as i64)
+                    .ok_or(Error::DeltaOverflow(node_index))?;
             }
 
             // Apply the delta to the node.
@@ -428,7 +425,7 @@ impl ProtoArray {
                     return Err(Error::InvalidAncestorOfValidPayload {
                         ancestor_block_root: node.root,
                         ancestor_payload_block_hash,
-                    })
+                    });
                 }
             };
 
@@ -537,7 +534,7 @@ impl ProtoArray {
                         return Err(Error::ValidExecutionStatusBecameInvalid {
                             block_root: node.root,
                             payload_block_hash: *hash,
-                        })
+                        });
                     }
                     ExecutionStatus::Optimistic(hash) => {
                         invalidated_indices.insert(index);
@@ -594,27 +591,27 @@ impl ProtoArray {
                 .get_mut(index)
                 .ok_or(Error::InvalidNodeIndex(index))?;
 
-            if let Some(parent_index) = node.parent {
-                if invalidated_indices.contains(&parent_index) {
-                    match &node.execution_status {
-                        ExecutionStatus::Valid(hash) => {
-                            return Err(Error::ValidExecutionStatusBecameInvalid {
-                                block_root: node.root,
-                                payload_block_hash: *hash,
-                            })
-                        }
-                        ExecutionStatus::Optimistic(hash) | ExecutionStatus::Invalid(hash) => {
-                            node.execution_status = ExecutionStatus::Invalid(*hash)
-                        }
-                        ExecutionStatus::Irrelevant(_) => {
-                            return Err(Error::IrrelevantDescendant {
-                                block_root: node.root,
-                            })
-                        }
+            if let Some(parent_index) = node.parent
+                && invalidated_indices.contains(&parent_index)
+            {
+                match &node.execution_status {
+                    ExecutionStatus::Valid(hash) => {
+                        return Err(Error::ValidExecutionStatusBecameInvalid {
+                            block_root: node.root,
+                            payload_block_hash: *hash,
+                        });
+                    }
+                    ExecutionStatus::Optimistic(hash) | ExecutionStatus::Invalid(hash) => {
+                        node.execution_status = ExecutionStatus::Invalid(*hash)
+                    }
+                    ExecutionStatus::Irrelevant(_) => {
+                        return Err(Error::IrrelevantDescendant {
+                            block_root: node.root,
+                        });
                     }
-
-                    invalidated_indices.insert(index);
                 }
+
+                invalidated_indices.insert(index);
             }
         }
 

consensus/proto_array/src/proto_array_fork_choice.rs

@@ -1,11 +1,11 @@
 use crate::{
+    JustifiedBalances,
     error::Error,
     proto_array::{
-        calculate_committee_fraction, InvalidationOperation, Iter, ProposerBoost, ProtoArray,
-        ProtoNode,
+        InvalidationOperation, Iter, ProposerBoost, ProtoArray, ProtoNode,
+        calculate_committee_fraction,
     },
     ssz_container::SszContainer,
-    JustifiedBalances,
 };
 use serde::{Deserialize, Serialize};
 use ssz::{Decode, Encode};
@@ -705,24 +705,22 @@ impl ProtoArrayForkChoice {
 
                     // If the invalid root was boosted, apply the weight to it and
                     // ancestors.
-                    if let Some(proposer_score_boost) = spec.proposer_score_boost {
-                        if self.proto_array.previous_proposer_boost.root == node.root {
-                            // Compute the score based upon the current balances. We can't rely on
-                            // the `previous_proposr_boost.score` since it is set to zero with an
-                            // invalid node.
-                            let proposer_score = calculate_committee_fraction::<E>(
-                                &self.balances,
-                                proposer_score_boost,
-                            )
-                            .ok_or("Failed to compute proposer boost")?;
-                            // Store the score we've applied here so it can be removed in
-                            // a later call to `apply_score_changes`.
-                            self.proto_array.previous_proposer_boost.score = proposer_score;
-                            // Apply this boost to this node.
-                            restored_weight = restored_weight
-                                .checked_add(proposer_score)
-                                .ok_or("Overflow when adding boost to weight")?;
-                        }
+                    if let Some(proposer_score_boost) = spec.proposer_score_boost
+                        && self.proto_array.previous_proposer_boost.root == node.root
+                    {
+                        // Compute the score based upon the current balances. We can't rely on
+                        // the `previous_proposr_boost.score` since it is set to zero with an
+                        // invalid node.
+                        let proposer_score =
+                            calculate_committee_fraction::<E>(&self.balances, proposer_score_boost)
+                                .ok_or("Failed to compute proposer boost")?;
+                        // Store the score we've applied here so it can be removed in
+                        // a later call to `apply_score_changes`.
+                        self.proto_array.previous_proposer_boost.score = proposer_score;
+                        // Apply this boost to this node.
+                        restored_weight = restored_weight
+                            .checked_add(proposer_score)
+                            .ok_or("Overflow when adding boost to weight")?;
                     }
 
                     // Add the restored weight to the node and all ancestors.
@@ -864,7 +862,7 @@ impl ProtoArrayForkChoice {
     pub fn iter_block_roots(
         &self,
         block_root: &Hash256,
-    ) -> impl Iterator<Item = (Hash256, Slot)> + use<'_> {
+    ) -> impl Iterator<Item = (Hash256, Slot)> + '_ {
         self.proto_array.iter_block_roots(block_root)
     }
 

consensus/proto_array/src/ssz_container.rs

@@ -1,10 +1,10 @@
 use crate::proto_array::ProposerBoost;
 use crate::{
+    Error, JustifiedBalances,
     proto_array::{ProtoArray, ProtoNodeV17},
     proto_array_fork_choice::{ElasticList, ProtoArrayForkChoice, VoteTracker},
-    Error, JustifiedBalances,
 };
-use ssz::{four_byte_option_impl, Encode};
+use ssz::{Encode, four_byte_option_impl};
 use ssz_derive::{Decode, Encode};
 use std::collections::HashMap;
 use superstruct::superstruct;