From 2d3354551ed311a5d8043d469a99e018508a48be Mon Sep 17 00:00:00 2001 From: Daniel Knopik Date: Wed, 29 Apr 2026 15:35:31 +0200 Subject: [PATCH] error handling and wiring up --- beacon_node/beacon_chain/src/beacon_chain.rs | 101 ++++++++++-------- beacon_node/beacon_chain/src/errors.rs | 10 ++ .../fetch_blobs/fetch_blobs_beacon_adapter.rs | 2 +- .../beacon_chain/src/fetch_blobs/mod.rs | 6 +- beacon_node/beacon_chain/src/lib.rs | 2 +- .../payload_envelope_verification/import.rs | 1 + .../src/payload_envelope_verification/mod.rs | 6 +- beacon_node/http_api/src/publish_blocks.rs | 2 +- beacon_node/network/src/metrics.rs | 4 +- .../gossip_methods.rs | 8 +- .../src/network_beacon_processor/mod.rs | 13 ++- .../network_beacon_processor/sync_methods.rs | 11 +- .../network/src/sync/block_lookups/mod.rs | 21 +++- beacon_node/network/src/sync/manager.rs | 19 ++-- beacon_node/network/src/sync/tests/lookups.rs | 10 +- 15 files changed, 132 insertions(+), 84 deletions(-) diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index 3e776f17fd..78c59bf661 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -3275,7 +3275,7 @@ impl BeaconChain { pub async fn process_gossip_blob( self: &Arc, blob: GossipVerifiedBlob, - ) -> Result { + ) -> Result { let block_root = blob.block_root(); // If this block has already been imported to forkchoice it must have been available, so @@ -3285,12 +3285,12 @@ impl BeaconChain { .fork_choice_read_lock() .contains_block(&block_root) { - return Err(BlockError::DuplicateFullyImported(blob.block_root()).into()); + return Err(BlockError::DuplicateFullyImported(blob.block_root())); } // No need to process and import blobs beyond the PeerDAS epoch. if self.spec.is_peer_das_enabled_for_epoch(blob.epoch()) { - return Err(BlockError::BlobNotRequired(blob.slot()).into()); + return Err(BlockError::BlobNotRequired(blob.slot())); } self.emit_sse_blob_sidecar_events(&block_root, std::iter::once(blob.as_blob())); @@ -3456,7 +3456,7 @@ impl BeaconChain { slot: Slot, block_root: Hash256, blobs: FixedBlobSidecarList, - ) -> Result { + ) -> Result { // If this block has already been imported to forkchoice it must have been available, so // we don't need to process its blobs again. if self @@ -3464,7 +3464,7 @@ impl BeaconChain { .fork_choice_read_lock() .contains_block(&block_root) { - return Err(BlockError::DuplicateFullyImported(block_root).into()); + return Err(BlockError::DuplicateFullyImported(block_root)); } // Reject RPC blobs referencing unknown parents. Otherwise we allow potentially invalid data @@ -3479,7 +3479,7 @@ impl BeaconChain { .fork_choice_read_lock() .contains_block(&parent_root) { - return Err(BlockError::ParentUnknown { parent_root }.into()); + return Err(BlockError::ParentUnknown { parent_root }); } self.emit_sse_blob_sidecar_events(&block_root, blobs.iter().flatten().map(Arc::as_ref)); @@ -3684,9 +3684,10 @@ impl BeaconChain { return Ok(None); }; - self.process_payload_availability(slot, availability, || Ok(())) + Ok(self + .process_payload_availability(slot, availability, || Ok(())) .await - .map(|status| Some((status, data_columns_to_publish))) + .map(|status| Some((status, data_columns_to_publish)))?) } DataColumnReconstructionResultV2::NotStarted(reason) | DataColumnReconstructionResultV2::RecoveredColumnsNotImported(reason) => { @@ -3698,14 +3699,15 @@ impl BeaconChain { } } } else { - let pending_block_cache = self.data_availability_checker.clone(); + let data_availability_checker = self.data_availability_checker.clone(); let result = self .task_executor .spawn_blocking_with_rayon_async(RayonPoolType::HighPriority, move || { - pending_block_cache.reconstruct_data_columns(&block_root) + data_availability_checker.reconstruct_data_columns(&block_root) }) .await - .map_err(|_| BeaconChainError::RuntimeShutdown)??; + .map_err(|_| BlockError::from(BeaconChainError::RuntimeShutdown))? + .map_err(BlockError::from)?; match result { DataColumnReconstructionResultV1::Success(( @@ -3716,9 +3718,10 @@ impl BeaconChain { return Ok(None); }; - self.process_availability(slot, availability, || Ok(())) + Ok(self + .process_availability(slot, availability, || Ok(())) .await - .map(|status| Some((status, data_columns_to_publish))) + .map(|status| Some((status, data_columns_to_publish)))?) } DataColumnReconstructionResultV1::NotStarted(reason) | DataColumnReconstructionResultV1::RecoveredColumnsNotImported(reason) => { @@ -3939,7 +3942,7 @@ impl BeaconChain { async fn check_gossip_blob_availability_and_import( self: &Arc, blob: GossipVerifiedBlob, - ) -> Result { + ) -> Result { let slot = blob.slot(); if let Some(slasher) = self.slasher.as_ref() { slasher.accept_block_header(blob.signed_block_header()); @@ -3980,15 +3983,19 @@ impl BeaconChain { { let availability = self .pending_payload_cache - .put_gossip_verified_data_columns(block_root, slot, data_columns)?; - self.process_payload_availability(slot, availability, publish_fn) - .await + .put_gossip_verified_data_columns(block_root, slot, data_columns) + .map_err(EnvelopeError::from)?; + Ok(self + .process_payload_availability(slot, availability, publish_fn) + .await?) } else { let availability = self .data_availability_checker - .put_gossip_verified_data_columns(block_root, slot, data_columns)?; - self.process_availability(slot, availability, publish_fn) - .await + .put_gossip_verified_data_columns(block_root, slot, data_columns) + .map_err(BlockError::from)?; + Ok(self + .process_availability(slot, availability, publish_fn) + .await?) } } @@ -4029,7 +4036,7 @@ impl BeaconChain { slot: Slot, block_root: Hash256, blobs: FixedBlobSidecarList, - ) -> Result { + ) -> Result { self.check_blob_header_signature_and_slashability( block_root, blobs.iter().flatten().map(Arc::as_ref), @@ -4057,10 +4064,12 @@ impl BeaconChain { )?; let availability = self .data_availability_checker - .put_kzg_verified_blobs(block_root, blobs)?; + .put_kzg_verified_blobs(block_root, blobs) + .map_err(BlockError::from)?; - self.process_availability(slot, availability, || Ok(())) - .await + Ok(self + .process_availability(slot, availability, || Ok(())) + .await?) } EngineGetBlobsOutput::CustodyColumns(data_columns) => { // TODO(gloas) verify that this check is no longer relevant for gloas @@ -4080,15 +4089,19 @@ impl BeaconChain { { let availability = self .pending_payload_cache - .put_kzg_verified_custody_data_columns(block_root, data_columns)?; - self.process_payload_availability(slot, availability, || Ok(())) - .await + .put_kzg_verified_custody_data_columns(block_root, data_columns) + .map_err(EnvelopeError::from)?; + Ok(self + .process_payload_availability(slot, availability, || Ok(())) + .await?) } else { let availability = self .data_availability_checker - .put_kzg_verified_custody_data_columns(block_root, data_columns)?; - self.process_availability(slot, availability, || Ok(())) - .await + .put_kzg_verified_custody_data_columns(block_root, data_columns) + .map_err(BlockError::from)?; + Ok(self + .process_availability(slot, availability, || Ok(())) + .await?) } } } @@ -4116,21 +4129,21 @@ impl BeaconChain { .fork_name_at_slot::(slot) .gloas_enabled() { - let availability = self.pending_payload_cache.put_rpc_custody_columns( - block_root, - slot, - custody_columns, - )?; - self.process_payload_availability(slot, availability, || Ok(())) - .await + let availability = self + .pending_payload_cache + .put_rpc_custody_columns(block_root, slot, custody_columns) + .map_err(EnvelopeError::from)?; + Ok(self + .process_payload_availability(slot, availability, || Ok(())) + .await?) } else { - let availability = self.data_availability_checker.put_rpc_custody_columns( - block_root, - slot, - custody_columns, - )?; - self.process_availability(slot, availability, || Ok(())) - .await + let availability = self + .data_availability_checker + .put_rpc_custody_columns(block_root, slot, custody_columns) + .map_err(BlockError::from)?; + Ok(self + .process_availability(slot, availability, || Ok(())) + .await?) } } diff --git a/beacon_node/beacon_chain/src/errors.rs b/beacon_node/beacon_chain/src/errors.rs index 68c560611c..361521cea5 100644 --- a/beacon_node/beacon_chain/src/errors.rs +++ b/beacon_node/beacon_chain/src/errors.rs @@ -337,6 +337,7 @@ easy_from_to!(StateAdvanceError, BlockProductionError); easy_from_to!(ForkChoiceError, BlockProductionError); easy_from_to!(EpochCacheError, BlockProductionError); +#[derive(Debug)] pub enum BlockOrEnvelopeError { BlockError(BlockError), EnvelopeError(EnvelopeError), @@ -344,3 +345,12 @@ pub enum BlockOrEnvelopeError { easy_from_to!(BlockError, BlockOrEnvelopeError); easy_from_to!(EnvelopeError, BlockOrEnvelopeError); + +impl AsRef for BlockOrEnvelopeError { + fn as_ref(&self) -> &str { + match self { + BlockOrEnvelopeError::BlockError(e) => e.as_ref(), + BlockOrEnvelopeError::EnvelopeError(e) => e.as_ref(), + } + } +} diff --git a/beacon_node/beacon_chain/src/fetch_blobs/fetch_blobs_beacon_adapter.rs b/beacon_node/beacon_chain/src/fetch_blobs/fetch_blobs_beacon_adapter.rs index abfcc8508f..32e14ad42a 100644 --- a/beacon_node/beacon_chain/src/fetch_blobs/fetch_blobs_beacon_adapter.rs +++ b/beacon_node/beacon_chain/src/fetch_blobs/fetch_blobs_beacon_adapter.rs @@ -138,7 +138,7 @@ impl FetchBlobsBeaconAdapter { self.chain .process_engine_blobs(slot, block_root, blobs) .await - .map_err(FetchEngineBlobError::BlobProcessingError) + .map_err(|e| FetchEngineBlobError::BlobProcessingError(Box::new(e))) } pub(crate) fn fork_choice_contains_block(&self, block_root: &Hash256) -> bool { diff --git a/beacon_node/beacon_chain/src/fetch_blobs/mod.rs b/beacon_node/beacon_chain/src/fetch_blobs/mod.rs index e2ac20509b..a1251b8622 100644 --- a/beacon_node/beacon_chain/src/fetch_blobs/mod.rs +++ b/beacon_node/beacon_chain/src/fetch_blobs/mod.rs @@ -16,13 +16,13 @@ use crate::blob_verification::{GossipBlobError, KzgVerifiedBlob}; use crate::data_column_verification::{ KzgVerifiedCustodyDataColumn, KzgVerifiedCustodyPartialDataColumn, KzgVerifiedPartialDataColumn, }; +use crate::errors::BlockOrEnvelopeError; #[cfg_attr(test, double)] use crate::fetch_blobs::fetch_blobs_beacon_adapter::FetchBlobsBeaconAdapter; use crate::kzg_utils::blobs_to_partial_data_columns; use crate::observed_data_sidecars::ObservationKey; use crate::{ - AvailabilityProcessingStatus, BeaconChain, BeaconChainError, BeaconChainTypes, BlockError, - metrics, + AvailabilityProcessingStatus, BeaconChain, BeaconChainError, BeaconChainTypes, metrics, }; use execution_layer::Error as ExecutionLayerError; use execution_layer::json_structures::{BlobAndProofV1, BlobAndProofV2, BlobAndProofV3}; @@ -50,7 +50,7 @@ pub enum EngineGetBlobsOutput { pub enum FetchEngineBlobError { BeaconStateError(BeaconStateError), BeaconChainError(Box), - BlobProcessingError(BlockError), + BlobProcessingError(Box), BlobSidecarError(BlobSidecarError), DataColumnSidecarError(DataColumnSidecarError), ExecutionLayerMissing, diff --git a/beacon_node/beacon_chain/src/lib.rs b/beacon_node/beacon_chain/src/lib.rs index 804268a613..bd9c4a7c12 100644 --- a/beacon_node/beacon_chain/src/lib.rs +++ b/beacon_node/beacon_chain/src/lib.rs @@ -76,7 +76,7 @@ pub use self::beacon_chain::{ }; pub use self::beacon_snapshot::BeaconSnapshot; pub use self::chain_config::ChainConfig; -pub use self::errors::{BeaconChainError, BlockProductionError}; +pub use self::errors::{BeaconChainError, BlockOrEnvelopeError, BlockProductionError}; pub use self::historical_blocks::HistoricalBlockError; pub use attestation_verification::Error as AttestationError; pub use beacon_fork_choice_store::{ diff --git a/beacon_node/beacon_chain/src/payload_envelope_verification/import.rs b/beacon_node/beacon_chain/src/payload_envelope_verification/import.rs index 2d371a5315..ccd31e94b7 100644 --- a/beacon_node/beacon_chain/src/payload_envelope_verification/import.rs +++ b/beacon_node/beacon_chain/src/payload_envelope_verification/import.rs @@ -92,6 +92,7 @@ impl BeaconChain { } self.check_envelope_availability_and_import(executed_envelope) + .await }; // Verify and import the payload envelope. diff --git a/beacon_node/beacon_chain/src/payload_envelope_verification/mod.rs b/beacon_node/beacon_chain/src/payload_envelope_verification/mod.rs index 75c0f34363..cbb25a64f2 100644 --- a/beacon_node/beacon_chain/src/payload_envelope_verification/mod.rs +++ b/beacon_node/beacon_chain/src/payload_envelope_verification/mod.rs @@ -18,10 +18,10 @@ //! //! ``` -use std::sync::Arc; - use state_processing::{BlockProcessingError, envelope_processing::EnvelopeProcessingError}; +use std::sync::Arc; use store::Error as DBError; +use strum::AsRefStr; use tracing::instrument; use types::{ BeaconState, BeaconStateError, DataColumnSidecarList, EthSpec, ExecutionBlockHash, @@ -190,7 +190,7 @@ impl AvailableExecutedEnvelope { } } -#[derive(Debug)] +#[derive(Debug, AsRefStr)] pub enum EnvelopeError { /// The envelope's block root is unknown. BlockRootUnknown { block_root: Hash256 }, diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs index 644ade956a..e96c86b17f 100644 --- a/beacon_node/http_api/src/publish_blocks.rs +++ b/beacon_node/http_api/src/publish_blocks.rs @@ -246,7 +246,7 @@ pub async fn publish_block>( if let Err(e) = Box::pin(chain.process_gossip_data_columns(sampling_columns, publish_fn)).await { - let msg = format!("Invalid data column: {e}"); + let msg = format!("Invalid data column: {e:?}"); return if let BroadcastValidation::Gossip = validation_level { Err(warp_utils::reject::broadcast_without_import(msg)) } else { diff --git a/beacon_node/network/src/metrics.rs b/beacon_node/network/src/metrics.rs index b09dc95db4..4b34d7bfc0 100644 --- a/beacon_node/network/src/metrics.rs +++ b/beacon_node/network/src/metrics.rs @@ -1,5 +1,5 @@ use beacon_chain::{ - AvailabilityProcessingStatus, BlockError, attestation_verification::Error as AttnError, + AvailabilityProcessingStatus, attestation_verification::Error as AttnError, light_client_finality_update_verification::Error as LightClientFinalityUpdateError, light_client_optimistic_update_verification::Error as LightClientOptimisticUpdateError, sync_committee_verification::Error as SyncCommitteeError, @@ -733,7 +733,7 @@ pub fn register_sync_committee_error(error: &SyncCommitteeError) { } pub(crate) fn register_process_result_metrics( - result: &std::result::Result, + result: &std::result::Result>, source: BlockSource, block_component: &'static str, ) { diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs index c83fd9244d..5e291bd833 100644 --- 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, ForkChoiceError, - GossipVerifiedBlock, NotifyExecutionLayer, + AvailabilityProcessingStatus, BeaconChainError, BeaconChainTypes, BlockError, + BlockOrEnvelopeError, ForkChoiceError, GossipVerifiedBlock, NotifyExecutionLayer, attestation_verification::{self, Error as AttnError, VerifiedAttestation}, data_availability_checker::AvailabilityCheckErrorCategory, light_client_finality_update_verification::Error as LightClientFinalityUpdateError, @@ -1387,7 +1387,7 @@ impl NetworkBeaconProcessor { self.check_reconstruction_trigger(slot, &block_root).await; } }, - Err(BlockError::DuplicateFullyImported(_)) => { + Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => { debug!( ?block_root, data_column_index, "Ignoring gossip column already imported" @@ -1518,7 +1518,7 @@ impl NetworkBeaconProcessor { self.check_reconstruction_trigger(*slot, block_root).await; } }, - Err(BlockError::DuplicateFullyImported(_)) => { + Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => { debug!( ?block_root, data_column_index, "Ignoring completed gossip column already imported" diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs index 23515d5901..7a978548a7 100644 --- a/beacon_node/network/src/network_beacon_processor/mod.rs +++ b/beacon_node/network/src/network_beacon_processor/mod.rs @@ -7,7 +7,9 @@ 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}; +use beacon_chain::{ + AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, BlockOrEnvelopeError, +}; use beacon_processor::{ BeaconProcessorSend, DuplicateCache, GossipAggregatePackage, GossipAttestationPackage, Work, WorkEvent as BeaconWorkEvent, @@ -980,9 +982,10 @@ impl NetworkBeaconProcessor { "Fetch blobs completed without import" ); } - Err(FetchEngineBlobError::BlobProcessingError(BlockError::DuplicateFullyImported( - .., - ))) => { + Err(FetchEngineBlobError::BlobProcessingError(e)) + if let BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(..)) = + *e => + { debug!( %block_root, "Fetch blobs duplicate import" @@ -1050,7 +1053,7 @@ impl NetworkBeaconProcessor { "Reconstruction not required for block" ); } - Err(BlockError::DuplicateFullyImported(_)) => { + Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => { debug!("Block already imported in parallel with reconstruction"); } Err(e) => { diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs index 988a68c9dd..03be073e7d 100644 --- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs +++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs @@ -11,8 +11,9 @@ 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, ChainSegmentResult, - HistoricalBlockError, NotifyExecutionLayer, validator_monitor::get_slot_delay_ms, + AvailabilityProcessingStatus, BeaconChainTypes, BlockError, BlockOrEnvelopeError, + ChainSegmentResult, HistoricalBlockError, NotifyExecutionLayer, + validator_monitor::get_slot_delay_ms, }; use beacon_processor::{ AsyncFn, BlockingFn, DuplicateCache, @@ -234,7 +235,7 @@ impl NetworkBeaconProcessor { // Sync handles these results self.send_sync_message(SyncMessage::BlockComponentProcessed { process_type, - result: result.into(), + result: result.map_err(Into::into).into(), }); // Drop the handle to remove the entry from the cache @@ -345,7 +346,7 @@ impl NetworkBeaconProcessor { // Sync handles these results self.send_sync_message(SyncMessage::BlockComponentProcessed { process_type, - result: result.into(), + result: result.map_err(Into::into).into(), }); } @@ -410,7 +411,7 @@ impl NetworkBeaconProcessor { ); } }, - Err(BlockError::DuplicateFullyImported(_)) => { + Err(BlockOrEnvelopeError::BlockError(BlockError::DuplicateFullyImported(_))) => { debug!( block_hash = %block_root, "Custody columns have already been imported" diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs index 3929f74aa0..ab9c7bbe38 100644 --- a/beacon_node/network/src/sync/block_lookups/mod.rs +++ b/beacon_node/network/src/sync/block_lookups/mod.rs @@ -33,7 +33,9 @@ use beacon_chain::block_verification_types::AsBlock; use beacon_chain::data_availability_checker::{ AvailabilityCheckError, AvailabilityCheckErrorCategory, }; -use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError}; +use beacon_chain::{ + AvailabilityProcessingStatus, BeaconChainTypes, BlockError, BlockOrEnvelopeError, +}; pub use common::RequestState; use fnv::FnvHashMap; use lighthouse_network::service::api_types::SingleLookupReqId; @@ -589,8 +591,12 @@ impl BlockLookups { let action = match result { BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(_)) - | BlockProcessingResult::Err(BlockError::DuplicateFullyImported(..)) - | BlockProcessingResult::Err(BlockError::GenesisBlock) => { + | BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError( + BlockError::DuplicateFullyImported(..), + )) + | BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError( + BlockError::GenesisBlock, + )) => { // Successfully imported request_state.on_processing_success()?; Action::Continue @@ -614,7 +620,9 @@ impl BlockLookups { Action::Retry } } - BlockProcessingResult::Err(BlockError::DuplicateImportStatusUnknown(..)) => { + BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError( + 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"); @@ -630,6 +638,11 @@ impl BlockLookups { 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 diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs index 734295ac1d..fb31e92262 100644 --- a/beacon_node/network/src/sync/manager.rs +++ b/beacon_node/network/src/sync/manager.rs @@ -50,7 +50,8 @@ 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, EngineState, + AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, BlockOrEnvelopeError, + EngineState, }; use futures::StreamExt; use lighthouse_network::SyncInfo; @@ -206,7 +207,7 @@ impl BlockProcessType { #[derive(Debug)] pub enum BlockProcessingResult { Ok(AvailabilityProcessingStatus), - Err(BlockError), + Err(BlockOrEnvelopeError), Ignored, } @@ -1449,8 +1450,8 @@ impl SyncManager { } } -impl From> for BlockProcessingResult { - fn from(result: Result) -> Self { +impl From> for BlockProcessingResult { + fn from(result: Result) -> Self { match result { Ok(status) => BlockProcessingResult::Ok(status), Err(e) => BlockProcessingResult::Err(e), @@ -1458,8 +1459,14 @@ impl From> for BlockProcessingR } } -impl From for BlockProcessingResult { - fn from(e: BlockError) -> Self { +impl From for BlockProcessingResult { + fn from(e: BlockOrEnvelopeError) -> Self { BlockProcessingResult::Err(e) } } + +impl From for BlockProcessingResult { + fn from(e: BlockError) -> Self { + BlockProcessingResult::Err(BlockOrEnvelopeError::BlockError(e)) + } +} diff --git a/beacon_node/network/src/sync/tests/lookups.rs b/beacon_node/network/src/sync/tests/lookups.rs index a26996ec5e..7b5cd74150 100644 --- a/beacon_node/network/src/sync/tests/lookups.rs +++ b/beacon_node/network/src/sync/tests/lookups.rs @@ -2089,8 +2089,7 @@ async fn too_many_processing_failures(depth: usize) { r.build_chain_and_trigger_last_block(depth).await; // Simulate that a peer always returns empty r.simulate( - SimulateConfig::new() - .with_process_result(|| BlockProcessingResult::Err(BlockError::BlockSlotLimitReached)), + SimulateConfig::new().with_process_result(|| BlockError::BlockSlotLimitReached.into()), ) .await; // We register multiple penalties, the lookup fails and sync does not progress @@ -2158,9 +2157,10 @@ async fn test_single_block_lookup_duplicate_response() { let mut r = TestRig::default(); r.build_chain_and_trigger_last_block(1).await; // Send a DuplicateFullyImported response, the lookup should complete successfully - r.simulate(SimulateConfig::new().with_process_result(|| { - BlockProcessingResult::Err(BlockError::DuplicateFullyImported(Hash256::ZERO)) - })) + r.simulate( + SimulateConfig::new() + .with_process_result(|| BlockError::DuplicateFullyImported(Hash256::ZERO).into()), + ) .await; // The block was not actually imported r.assert_head_slot(0);