Refactor

2026-05-30 20:57:10 +00:00 · 2026-04-30 13:39:05 +02:00
parent bd8cfa35f4
commit 0b7397eb4e
16 changed files with 116 additions and 206 deletions
--- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -14,8 +14,8 @@ use beacon_chain::payload_bid_verification::PayloadBidError;
 use beacon_chain::proposer_preferences_verification::ProposerPreferencesError;
 use beacon_chain::store::Error;
 use beacon_chain::{
-    AvailabilityProcessingStatus, BeaconChainError, BeaconChainTypes, BlockError,
-    BlockOrEnvelopeError, ForkChoiceError, GossipVerifiedBlock, NotifyExecutionLayer,
+    AvailabilityProcessingStatus, BeaconChainError, BeaconChainTypes, BlockError, ForkChoiceError,
+    GossipVerifiedBlock, NotifyExecutionLayer,
    attestation_verification::{self, Error as AttnError, VerifiedAttestation},
    data_availability_checker::AvailabilityCheckErrorCategory,
    light_client_finality_update_verification::Error as LightClientFinalityUpdateError,
@@ -1407,7 +1407,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    self.check_reconstruction_trigger(slot, &block_root).await;
                }
            },
-            Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => {
+            Err(BlockError::DuplicateFullyImported(_)) => {
                debug!(
                    ?block_root,
                    data_column_index, "Ignoring gossip column already imported"
@@ -1538,7 +1538,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    self.check_reconstruction_trigger(*slot, block_root).await;
                }
            },
-            Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => {
+            Err(BlockError::DuplicateFullyImported(_)) => {
                debug!(
                    ?block_root,
                    data_column_index, "Ignoring completed gossip column already imported"
@@ -1846,7 +1846,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                return None;
            }
            // BlobNotRequired is unreachable. Only constructed in `process_gossip_blob`
-            Err(e @ BlockError::InternalError(_)) | Err(e @ BlockError::BlobNotRequired(_)) => {
+            Err(e @ BlockError::InternalError(_))
+            | Err(e @ BlockError::BlobNotRequired(_))
+            | Err(e @ BlockError::EnvelopeBlockRootUnknown { .. })
+            | Err(e @ BlockError::OptimisticSyncNotSupported { .. }) => {
                error!(error = %e, "Internal block gossip validation error");
                return None;
            }
@@ -3833,8 +3836,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    | EnvelopeError::UnknownValidator { .. }
                    | EnvelopeError::IncorrectBlockProposer { .. }
                    | EnvelopeError::ExecutionPayloadError(_)
-                    | EnvelopeError::EnvelopeProcessingError(_)
-                    | EnvelopeError::BlockError(_) => {
+                    | EnvelopeError::EnvelopeProcessingError(_) => {
                        self.propagate_validation_result(
                            message_id,
                            peer_id,
@@ -3914,12 +3916,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    }

                    EnvelopeError::PriorToFinalization { .. }
-                    | EnvelopeError::OptimisticSyncNotSupported { .. }
                    | EnvelopeError::BeaconChainError(_)
                    | EnvelopeError::BeaconStateError(_)
-                    | EnvelopeError::BlockProcessingError(_)
-                    | EnvelopeError::InternalError(_)
-                    | EnvelopeError::AvailabilityCheck(_) => {
+                    | EnvelopeError::ImportError(_) => {
                        self.propagate_validation_result(
                            message_id,
                            peer_id,
@@ -4010,7 +4009,8 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                | EnvelopeError::BlockHashMismatch { .. }
                | EnvelopeError::UnknownValidator { .. }
                | EnvelopeError::IncorrectBlockProposer { .. }
-                | EnvelopeError::ExecutionPayloadError(_) => {
+                | EnvelopeError::ExecutionPayloadError(_)
+                | EnvelopeError::EnvelopeProcessingError(_) => {
                    self.gossip_penalize_peer(
                        peer_id,
                        PeerAction::LowToleranceError,
@@ -4018,23 +4018,11 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    );
                }

-                EnvelopeError::EnvelopeProcessingError(_)
-                | EnvelopeError::BlockError(_)
-                | EnvelopeError::BlockRootUnknown { .. } => {
-                    self.gossip_penalize_peer(
-                        peer_id,
-                        PeerAction::LowToleranceError,
-                        "gossip_envelope_processing_error",
-                    );
-                }
-
-                EnvelopeError::PriorToFinalization { .. }
-                | EnvelopeError::OptimisticSyncNotSupported { .. }
+                EnvelopeError::BlockRootUnknown { .. }
+                | EnvelopeError::PriorToFinalization { .. }
                | EnvelopeError::BeaconChainError(_)
                | EnvelopeError::BeaconStateError(_)
-                | EnvelopeError::BlockProcessingError(_)
-                | EnvelopeError::InternalError(_)
-                | EnvelopeError::AvailabilityCheck(_) => {}
+                | EnvelopeError::ImportError(_) => {}
            },
        }
    }
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -7,9 +7,7 @@ use beacon_chain::data_column_verification::{GossipDataColumnError, observe_goss
 use beacon_chain::fetch_blobs::{
    EngineGetBlobsOutput, FetchEngineBlobError, fetch_and_process_engine_blobs,
 };
-use beacon_chain::{
-    AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, BlockOrEnvelopeError,
-};
+use beacon_chain::{AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError};
 use beacon_processor::{
    BeaconProcessorSend, DuplicateCache, GossipAggregatePackage, GossipAttestationPackage, Work,
    WorkEvent as BeaconWorkEvent,
@@ -983,10 +981,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                );
            }
            Err(FetchEngineBlobError::BlobProcessingError(e))
-                if matches!(
-                    *e,
-                    BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(..))
-                ) =>
+                if matches!(*e, BlockError::DuplicateFullyImported(..)) =>
            {
                debug!(
                    %block_root,
@@ -1055,7 +1050,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    "Reconstruction not required for block"
                );
            }
-            Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => {
+            Err(BlockError::DuplicateFullyImported(_)) => {
                debug!("Block already imported in parallel with reconstruction");
            }
            Err(e) => {
--- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
@@ -11,9 +11,8 @@ use beacon_chain::block_verification_types::{AsBlock, RangeSyncBlock};
 use beacon_chain::data_availability_checker::AvailabilityCheckError;
 use beacon_chain::historical_data_columns::HistoricalDataColumnError;
 use beacon_chain::{
-    AvailabilityProcessingStatus, BeaconChainTypes, BlockError, BlockOrEnvelopeError,
-    ChainSegmentResult, HistoricalBlockError, NotifyExecutionLayer,
-    validator_monitor::get_slot_delay_ms,
+    AvailabilityProcessingStatus, BeaconChainTypes, BlockError, ChainSegmentResult,
+    HistoricalBlockError, NotifyExecutionLayer, validator_monitor::get_slot_delay_ms,
 };
 use beacon_processor::{
    AsyncFn, BlockingFn, DuplicateCache,
@@ -346,7 +345,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
        // Sync handles these results
        self.send_sync_message(SyncMessage::BlockComponentProcessed {
            process_type,
-            result: result.map_err(Into::into).into(),
+            result: result.into(),
        });
    }

@@ -411,7 +410,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                    );
                }
            },
-            Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => {
+            Err(BlockError::DuplicateFullyImported(_)) => {
                debug!(
                    block_hash = %block_root,
                    "Custody columns have already been imported"
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -33,9 +33,7 @@ use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::data_availability_checker::{
    AvailabilityCheckError, AvailabilityCheckErrorCategory,
 };
-use beacon_chain::{
-    AvailabilityProcessingStatus, BeaconChainTypes, BlockError, BlockOrEnvelopeError,
-};
+use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
 pub use common::RequestState;
 use fnv::FnvHashMap;
 use lighthouse_network::service::api_types::SingleLookupReqId;
@@ -591,12 +589,8 @@ impl<T: BeaconChainTypes> BlockLookups<T> {

        let action = match result {
            BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(_))
-            | BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError(
-                BlockError::DuplicateFullyImported(..),
-            ))
-            | BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError(
-                BlockError::GenesisBlock,
-            )) => {
+            | BlockProcessingResult::Err(BlockError::DuplicateFullyImported(..))
+            | BlockProcessingResult::Err(BlockError::GenesisBlock) => {
                // Successfully imported
                request_state.on_processing_success()?;
                Action::Continue
@@ -620,9 +614,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                    Action::Retry
                }
            }
-            BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError(
-                BlockError::DuplicateImportStatusUnknown(..),
-            )) => {
+            BlockProcessingResult::Err(BlockError::DuplicateImportStatusUnknown(..)) => {
                // This is unreachable because RPC blocks do not undergo gossip verification, and
                // this error can *only* come from gossip verification.
                error!(?block_root, "Single block lookup hit unreachable condition");
@@ -638,11 +630,6 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                Action::Drop("Block processing ignored".to_owned())
            }
            BlockProcessingResult::Err(e) => {
-                let BlockOrEnvelopeError::BlockError(e) = e else {
-                    // TODO(gloas): handle properly
-                    return Err(LookupRequestError::Failed(format!("{e:?}")));
-                };
-
                match e {
                    BlockError::BeaconChainError(e) => {
                        // Internal error
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -50,8 +50,7 @@ use crate::sync::custody_backfill_sync::CustodyBackFillSync;
 use crate::sync::network_context::{PeerGroup, RpcResponseResult};
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::{
-    AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, BlockOrEnvelopeError,
-    EngineState,
+    AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, EngineState,
 };
 use futures::StreamExt;
 use lighthouse_network::SyncInfo;
@@ -207,7 +206,7 @@ impl BlockProcessType {
 #[derive(Debug)]
 pub enum BlockProcessingResult {
    Ok(AvailabilityProcessingStatus),
-    Err(BlockOrEnvelopeError),
+    Err(BlockError),
    Ignored,
 }

@@ -1450,8 +1449,8 @@ impl<T: BeaconChainTypes> SyncManager<T> {
    }
 }

-impl From<Result<AvailabilityProcessingStatus, BlockOrEnvelopeError>> for BlockProcessingResult {
-    fn from(result: Result<AvailabilityProcessingStatus, BlockOrEnvelopeError>) -> Self {
+impl From<Result<AvailabilityProcessingStatus, BlockError>> for BlockProcessingResult {
+    fn from(result: Result<AvailabilityProcessingStatus, BlockError>) -> Self {
        match result {
            Ok(status) => BlockProcessingResult::Ok(status),
            Err(e) => BlockProcessingResult::Err(e),
@@ -1459,14 +1458,8 @@ impl From<Result<AvailabilityProcessingStatus, BlockOrEnvelopeError>> for BlockP
    }
 }

-impl From<BlockOrEnvelopeError> for BlockProcessingResult {
-    fn from(e: BlockOrEnvelopeError) -> Self {
+impl From<BlockError> for BlockProcessingResult {
+    fn from(e: BlockError) -> Self {
        BlockProcessingResult::Err(e)
    }
 }
-
-impl From<BlockError> for BlockProcessingResult {
-    fn from(e: BlockError) -> Self {
-        BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError(e))
-    }
-}