From b2e6b42dbfdbe916ca4ca0a01628aac661d89821 Mon Sep 17 00:00:00 2001 From: Eitan Seri- Levi Date: Fri, 27 Mar 2026 00:13:03 -0700 Subject: [PATCH] Remove lookup --- .../beacon_chain/src/block_verification.rs | 19 +-- .../src/service/api_types.rs | 2 - .../gossip_methods.rs | 24 ---- .../src/network_beacon_processor/mod.rs | 16 --- .../network_beacon_processor/sync_methods.rs | 79 +----------- beacon_node/network/src/router.rs | 30 +---- .../network/src/sync/block_lookups/mod.rs | 67 ---------- .../sync/block_lookups/single_block_lookup.rs | 19 +-- beacon_node/network/src/sync/manager.rs | 82 +------------ .../network/src/sync/network_context.rs | 114 +----------------- .../src/sync/network_context/requests.rs | 4 - .../requests/payload_envelopes_by_root.rs | 53 -------- 12 files changed, 16 insertions(+), 493 deletions(-) delete mode 100644 beacon_node/network/src/sync/network_context/requests/payload_envelopes_by_root.rs diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs index 5988a0b2b1..18d6d27748 100644 --- a/beacon_node/beacon_chain/src/block_verification.rs +++ b/beacon_node/beacon_chain/src/block_verification.rs @@ -321,13 +321,6 @@ pub enum BlockError { bid_parent_root: Hash256, block_parent_root: Hash256, }, - /// The parent block is known but its execution payload envelope has not been received yet. - /// - /// ## Peer scoring - /// - /// It's unclear if this block is valid, but it cannot be fully verified without the parent's - /// execution payload envelope. - ParentEnvelopeUnknown { parent_root: Hash256 }, } /// Which specific signature(s) are invalid in a SignedBeaconBlock @@ -1956,13 +1949,11 @@ fn load_parent>( if block.as_block().is_parent_block_full(parent_bid_block_hash) { // TODO(gloas): loading the envelope here is not very efficient // TODO(gloas): check parent payload existence prior to this point? - // If the parent's execution payload envelope hasn't arrived yet, - // return an unknown parent error so the block gets sent to the - // reprocess queue. - let envelope = chain - .store - .get_payload_envelope(&root)? - .ok_or(BlockError::ParentEnvelopeUnknown { parent_root: root })?; + let envelope = chain.store.get_payload_envelope(&root)?.ok_or_else(|| { + BeaconChainError::DBInconsistent(format!( + "Missing envelope for parent block {root:?}", + )) + })?; (StatePayloadStatus::Full, envelope.message.state_root) } else { (StatePayloadStatus::Pending, parent_block.state_root()) diff --git a/beacon_node/lighthouse_network/src/service/api_types.rs b/beacon_node/lighthouse_network/src/service/api_types.rs index a190a42a80..486a443857 100644 --- a/beacon_node/lighthouse_network/src/service/api_types.rs +++ b/beacon_node/lighthouse_network/src/service/api_types.rs @@ -31,8 +31,6 @@ pub enum SyncRequestId { BlobsByRange(BlobsByRangeRequestId), /// Data columns by range request DataColumnsByRange(DataColumnsByRangeRequestId), - /// Request searching for an execution payload envelope given a block root. - SinglePayloadEnvelope { id: SingleLookupReqId }, } /// Request ID for data_columns_by_root requests. Block lookups do not issue this request directly. 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 5e49c7b925..1f55d9a878 100644 --- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs +++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs @@ -1290,19 +1290,6 @@ impl NetworkBeaconProcessor { self.send_sync_message(SyncMessage::UnknownParentBlock(peer_id, block, block_root)); return None; } - Err(BlockError::ParentEnvelopeUnknown { parent_root }) => { - // The parent block is known but its execution payload envelope has not - // been received yet. Queue this block for reprocessing and trigger an - // envelope lookup. - debug!( - ?block_root, - ?parent_root, - "Parent envelope not yet available for gossip block" - ); - // TODO(gloas): trigger an envelope lookup for `parent_root` and queue - // this block for reprocessing once the envelope arrives. - return None; - } Err(e @ BlockError::BeaconChainError(_)) => { debug!( error = ?e, @@ -1591,17 +1578,6 @@ impl NetworkBeaconProcessor { "Block with unknown parent attempted to be processed" ); } - Err(BlockError::ParentEnvelopeUnknown { parent_root }) => { - // The parent block is known but its execution payload envelope has not - // been received yet. - debug!( - %block_root, - ?parent_root, - "Parent envelope not yet available, need envelope lookup" - ); - // TODO(gloas): trigger an envelope lookup for `parent_root` and queue - // this block for reprocessing once the envelope arrives. - } Err(e @ BlockError::ExecutionPayloadError(epe)) if !epe.penalize_peer() => { debug!( error = %e, diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs index ca5710076b..f74e7dacfb 100644 --- a/beacon_node/network/src/network_beacon_processor/mod.rs +++ b/beacon_node/network/src/network_beacon_processor/mod.rs @@ -541,22 +541,6 @@ impl NetworkBeaconProcessor { }) } - /// Create a new `Work` event for an RPC payload envelope. - pub fn send_rpc_payload_envelope( - self: &Arc, - envelope: Arc>, - seen_timestamp: Duration, - process_type: BlockProcessType, - ) -> Result<(), Error> { - let process_fn = - self.clone() - .generate_rpc_envelope_process_fn(envelope, seen_timestamp, process_type); - self.try_send(BeaconWorkEvent { - drop_during_sync: false, - work: Work::RpcPayloadEnvelope { process_fn }, - }) - } - /// Create a new `Work` event for some blobs, where the result from computation (if any) is /// sent to the other side of `result_tx`. pub fn send_rpc_blobs( 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 b4586994e4..f5769f15b2 100644 --- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs +++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs @@ -4,7 +4,7 @@ use crate::sync::BatchProcessResult; use crate::sync::manager::CustodyBatchProcessResult; use crate::sync::{ ChainId, - manager::{BlockProcessType, BlockProcessingResult, SyncMessage}, + manager::{BlockProcessType, SyncMessage}, }; use beacon_chain::block_verification_types::LookupBlock; use beacon_chain::block_verification_types::{AsBlock, RangeSyncBlock}; @@ -28,9 +28,7 @@ use store::KzgCommitment; use tracing::{debug, debug_span, error, info, instrument, warn}; use types::data::FixedBlobSidecarList; use types::kzg_ext::format_kzg_commitments; -use types::{ - BlockImportSource, DataColumnSidecarList, Epoch, Hash256, SignedExecutionPayloadEnvelope, -}; +use types::{BlockImportSource, DataColumnSidecarList, Epoch, Hash256}; /// Id associated to a batch processing request, either a sync batch or a parent lookup. #[derive(Clone, Debug, PartialEq)] @@ -76,79 +74,6 @@ impl NetworkBeaconProcessor { } /// Returns an async closure which processes a payload envelope received via RPC. - pub fn generate_rpc_envelope_process_fn( - self: Arc, - envelope: Arc>, - seen_timestamp: Duration, - process_type: BlockProcessType, - ) -> AsyncFn { - let process_fn = async move { - self.process_rpc_envelope(envelope, seen_timestamp, process_type) - .await; - }; - Box::pin(process_fn) - } - - /// Process an execution payload envelope received via RPC. - async fn process_rpc_envelope( - self: Arc, - envelope: Arc>, - _seen_timestamp: Duration, - process_type: BlockProcessType, - ) { - let beacon_block_root = envelope.beacon_block_root(); - - // Verify the envelope using the gossip verification path (same checks apply to RPC) - let verified_envelope = match self.chain.verify_envelope_for_gossip(envelope).await { - Ok(verified) => verified, - Err(e) => { - debug!( - error = ?e, - ?beacon_block_root, - "RPC payload envelope failed verification" - ); - self.send_sync_message(SyncMessage::BlockComponentProcessed { - process_type, - result: BlockProcessingResult::Err(BlockError::InternalError(format!( - "Envelope verification failed: {e:?}" - ))), - }); - return; - } - }; - - // Process the verified envelope - let result = self - .chain - .process_execution_payload_envelope( - beacon_block_root, - verified_envelope, - NotifyExecutionLayer::Yes, - BlockImportSource::Lookup, - || Ok(()), - ) - .await; - - let processing_result = match result { - Ok(status) => BlockProcessingResult::Ok(status), - Err(e) => { - debug!( - error = ?e, - ?beacon_block_root, - "RPC payload envelope processing failed" - ); - BlockProcessingResult::Err(BlockError::InternalError(format!( - "Envelope processing failed: {e:?}" - ))) - } - }; - - self.send_sync_message(SyncMessage::BlockComponentProcessed { - process_type, - result: processing_result, - }); - } - /// Returns the `process_fn` and `ignore_fn` required when requeuing an RPC block. pub fn generate_lookup_beacon_block_fns( self: Arc, diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs index 3fb2196975..90c672ea95 100644 --- a/beacon_node/network/src/router.rs +++ b/beacon_node/network/src/router.rs @@ -713,34 +713,14 @@ impl Router { pub fn on_payload_envelopes_by_root_response( &mut self, peer_id: PeerId, - app_request_id: AppRequestId, - envelope: Option>>, + _app_request_id: AppRequestId, + _envelope: Option>>, ) { - let sync_request_id = match app_request_id { - AppRequestId::Sync(sync_id) => match sync_id { - id @ SyncRequestId::SinglePayloadEnvelope { .. } => id, - other => { - crit!(request = ?other, "PayloadEnvelopesByRoot response on incorrect request"); - return; - } - }, - AppRequestId::Router => { - crit!(%peer_id, "All PayloadEnvelopesByRoot requests belong to sync"); - return; - } - AppRequestId::Internal => unreachable!("Handled internally"), - }; - - trace!( + // TODO(EIP-7732): Envelope lookup sync not yet implemented on this branch. + crit!( %peer_id, - "Received PayloadEnvelopesByRoot Response" + "Received unexpected PayloadEnvelopesByRoot response" ); - self.send_to_sync(SyncMessage::RpcPayloadEnvelope { - peer_id, - sync_request_id, - envelope, - seen_timestamp: timestamp_now(), - }); } /// Handle a `BlobsByRoot` response from the peer. diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs index 7b4e3ce753..394f2fc37d 100644 --- a/beacon_node/network/src/sync/block_lookups/mod.rs +++ b/beacon_node/network/src/sync/block_lookups/mod.rs @@ -109,7 +109,6 @@ pub type SingleLookupId = u32; enum Action { Retry, ParentUnknown { parent_root: Hash256 }, - ParentEnvelopeUnknown { parent_root: Hash256 }, Drop(/* reason: */ String), Continue, } @@ -560,19 +559,6 @@ impl BlockLookups { BlockProcessType::SingleCustodyColumn(id) => { self.on_processing_result_inner::>(id, result, cx) } - BlockProcessType::SinglePayloadEnvelope { id, block_root } => { - match result { - BlockProcessingResult::Ok(_) => { - self.continue_envelope_child_lookups(block_root, cx); - } - BlockProcessingResult::Err(e) => { - debug!(%id, error = ?e, "Payload envelope processing failed"); - // TODO(EIP-7732): resolve awaiting_envelope on affected lookups so they can retry - } - _ => {} - } - return; - } }; self.on_lookup_result(process_type.id(), lookup_result, "processing_result", cx); } @@ -659,12 +645,6 @@ impl BlockLookups { request_state.revert_to_awaiting_processing()?; Action::ParentUnknown { parent_root } } - BlockError::ParentEnvelopeUnknown { parent_root } => { - // The parent block is known but its execution payload envelope is missing. - // Revert to awaiting processing and fetch the envelope via RPC. - request_state.revert_to_awaiting_processing()?; - Action::ParentEnvelopeUnknown { parent_root } - } ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => { // These errors indicate that the execution layer is offline // and failed to validate the execution payload. Do not downscore peer. @@ -762,26 +742,6 @@ impl BlockLookups { ))) } } - Action::ParentEnvelopeUnknown { parent_root } => { - let peers = lookup.all_peers(); - lookup.set_awaiting_envelope(parent_root); - // Pick a peer to request the envelope from - let peer_id = peers.first().copied().ok_or_else(|| { - LookupRequestError::Failed("No peers available for envelope request".to_owned()) - })?; - match cx.envelope_lookup_request(lookup_id, peer_id, parent_root) { - Ok(_) => { - debug!( - id = lookup_id, - ?block_root, - ?parent_root, - "Requesting missing parent envelope" - ); - Ok(LookupResult::Pending) - } - Err(e) => Err(LookupRequestError::SendFailedNetwork(e)), - } - } Action::Drop(reason) => { // Drop with noop Err(LookupRequestError::Failed(reason)) @@ -849,33 +809,6 @@ impl BlockLookups { } } - /// Makes progress on lookups that were waiting for a parent envelope to be imported. - pub fn continue_envelope_child_lookups( - &mut self, - block_root: Hash256, - cx: &mut SyncNetworkContext, - ) { - let mut lookup_results = vec![]; - - for (id, lookup) in self.single_block_lookups.iter_mut() { - if lookup.awaiting_envelope() == Some(block_root) { - lookup.resolve_awaiting_envelope(); - debug!( - envelope_root = ?block_root, - id, - block_root = ?lookup.block_root(), - "Continuing lookup after envelope imported" - ); - let result = lookup.continue_requests(cx); - lookup_results.push((*id, result)); - } - } - - for (id, result) in lookup_results { - self.on_lookup_result(id, result, "continue_envelope_child_lookups", cx); - } - } - /// Drops `dropped_id` lookup and all its children recursively. Lookups awaiting a parent need /// the parent to make progress to resolve, therefore we must drop them if the parent is /// dropped. diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs index 51cc191056..a82541fc53 100644 --- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs +++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs @@ -70,7 +70,6 @@ pub struct SingleBlockLookup { peers: Arc>>, block_root: Hash256, awaiting_parent: Option, - awaiting_envelope: Option, created: Instant, pub(crate) span: Span, } @@ -105,7 +104,6 @@ impl SingleBlockLookup { peers: Arc::new(RwLock::new(HashSet::from_iter(peers.iter().copied()))), block_root: requested_block_root, awaiting_parent, - awaiting_envelope: None, created: Instant::now(), span: lookup_span, } @@ -146,20 +144,6 @@ impl SingleBlockLookup { self.awaiting_parent = None; } - pub fn awaiting_envelope(&self) -> Option { - self.awaiting_envelope - } - - /// Mark this lookup as awaiting a parent envelope to be imported before processing. - pub fn set_awaiting_envelope(&mut self, parent_root: Hash256) { - self.awaiting_envelope = Some(parent_root); - } - - /// Mark this lookup as no longer awaiting a parent envelope. - pub fn resolve_awaiting_envelope(&mut self) { - self.awaiting_envelope = None; - } - /// Returns the time elapsed since this lookup was created pub fn elapsed_since_created(&self) -> Duration { self.created.elapsed() @@ -201,7 +185,6 @@ impl SingleBlockLookup { /// Returns true if this request is expecting some event to make progress pub fn is_awaiting_event(&self) -> bool { self.awaiting_parent.is_some() - || self.awaiting_envelope.is_some() || self.block_request_state.state.is_awaiting_event() || match &self.component_requests { // If components are waiting for the block request to complete, here we should @@ -304,7 +287,7 @@ impl SingleBlockLookup { expected_blobs: usize, ) -> Result<(), LookupRequestError> { let id = self.id; - let awaiting_event = self.awaiting_parent.is_some() || self.awaiting_envelope.is_some(); + let awaiting_event = self.awaiting_parent.is_some(); let request = R::request_state_mut(self).map_err(|e| LookupRequestError::BadState(e.to_owned()))?; diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs index eb896aa865..7e618d8980 100644 --- a/beacon_node/network/src/sync/manager.rs +++ b/beacon_node/network/src/sync/manager.rs @@ -74,8 +74,7 @@ use strum::IntoStaticStr; use tokio::sync::mpsc; use tracing::{debug, error, info, trace}; use types::{ - BlobSidecar, DataColumnSidecar, EthSpec, ForkContext, Hash256, SignedBeaconBlock, - SignedExecutionPayloadEnvelope, Slot, + BlobSidecar, DataColumnSidecar, EthSpec, ForkContext, Hash256, SignedBeaconBlock, Slot, }; /// The number of slots ahead of us that is allowed before requesting a long-range (batch) Sync @@ -134,14 +133,6 @@ pub enum SyncMessage { seen_timestamp: Duration, }, - /// An execution payload envelope has been received from the RPC. - RpcPayloadEnvelope { - sync_request_id: SyncRequestId, - peer_id: PeerId, - envelope: Option>>, - seen_timestamp: Duration, - }, - /// A block with an unknown parent has been received. UnknownParentBlock(PeerId, Arc>, Hash256), @@ -193,7 +184,6 @@ pub enum BlockProcessType { SingleBlock { id: Id }, SingleBlob { id: Id }, SingleCustodyColumn(Id), - SinglePayloadEnvelope { id: Id, block_root: Hash256 }, } impl BlockProcessType { @@ -201,8 +191,7 @@ impl BlockProcessType { match self { BlockProcessType::SingleBlock { id } | BlockProcessType::SingleBlob { id } - | BlockProcessType::SingleCustodyColumn(id) - | BlockProcessType::SinglePayloadEnvelope { id, .. } => *id, + | BlockProcessType::SingleCustodyColumn(id) => *id, } } } @@ -516,9 +505,6 @@ impl SyncManager { SyncRequestId::DataColumnsByRange(req_id) => { self.on_data_columns_by_range_response(req_id, peer_id, RpcEvent::RPCError(error)) } - SyncRequestId::SinglePayloadEnvelope { id } => { - self.on_single_envelope_response(id, peer_id, RpcEvent::RPCError(error)) - } } } @@ -853,17 +839,6 @@ impl SyncManager { } => { self.rpc_data_column_received(sync_request_id, peer_id, data_column, seen_timestamp) } - SyncMessage::RpcPayloadEnvelope { - sync_request_id, - peer_id, - envelope, - seen_timestamp, - } => self.rpc_payload_envelope_received( - sync_request_id, - peer_id, - envelope, - seen_timestamp, - ), SyncMessage::UnknownParentBlock(peer_id, block, block_root) => { let block_slot = block.slot(); let parent_root = block.parent_root(); @@ -1225,59 +1200,6 @@ impl SyncManager { } } - fn rpc_payload_envelope_received( - &mut self, - sync_request_id: SyncRequestId, - peer_id: PeerId, - envelope: Option>>, - seen_timestamp: Duration, - ) { - match sync_request_id { - SyncRequestId::SinglePayloadEnvelope { id } => self.on_single_envelope_response( - id, - peer_id, - RpcEvent::from_chunk(envelope, seen_timestamp), - ), - _ => { - crit!(%peer_id, "bad request id for payload envelope"); - } - } - } - - fn on_single_envelope_response( - &mut self, - id: SingleLookupReqId, - peer_id: PeerId, - rpc_event: RpcEvent>>, - ) { - if let Some(resp) = self - .network - .on_single_envelope_response(id, peer_id, rpc_event) - { - match resp { - Ok((envelope, seen_timestamp)) => { - let block_root = envelope.beacon_block_root(); - debug!( - ?block_root, - %id, - "Downloaded payload envelope, sending for processing" - ); - if let Err(e) = self.network.send_envelope_for_processing( - id.req_id, - envelope, - seen_timestamp, - block_root, - ) { - error!(error = ?e, "Failed to send envelope for processing"); - } - } - Err(e) => { - debug!(error = ?e, %id, "Payload envelope download failed"); - } - } - } - } - fn on_single_blob_response( &mut self, id: SingleLookupReqId, diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs index e9d289b777..ff630bb470 100644 --- a/beacon_node/network/src/sync/network_context.rs +++ b/beacon_node/network/src/sync/network_context.rs @@ -37,7 +37,6 @@ pub use requests::LookupVerifyError; use requests::{ ActiveRequests, BlobsByRangeRequestItems, BlobsByRootRequestItems, BlocksByRangeRequestItems, BlocksByRootRequestItems, DataColumnsByRangeRequestItems, DataColumnsByRootRequestItems, - PayloadEnvelopesByRootRequestItems, PayloadEnvelopesByRootSingleRequest, }; #[cfg(test)] use slot_clock::SlotClock; @@ -53,7 +52,7 @@ use tracing::{Span, debug, debug_span, error, warn}; use types::data::FixedBlobSidecarList; use types::{ BlobSidecar, BlockImportSource, ColumnIndex, DataColumnSidecar, DataColumnSidecarList, EthSpec, - ForkContext, Hash256, SignedBeaconBlock, SignedExecutionPayloadEnvelope, Slot, + ForkContext, Hash256, SignedBeaconBlock, Slot, }; pub mod custody; @@ -214,9 +213,6 @@ pub struct SyncNetworkContext { /// A mapping of active DataColumnsByRange requests data_columns_by_range_requests: ActiveRequests>, - /// A mapping of active PayloadEnvelopesByRoot requests - payload_envelopes_by_root_requests: - ActiveRequests>, /// Mapping of active custody column requests for a block root custody_by_root_requests: FnvHashMap>, @@ -302,7 +298,6 @@ impl SyncNetworkContext { blocks_by_range_requests: ActiveRequests::new("blocks_by_range"), blobs_by_range_requests: ActiveRequests::new("blobs_by_range"), data_columns_by_range_requests: ActiveRequests::new("data_columns_by_range"), - payload_envelopes_by_root_requests: ActiveRequests::new("payload_envelopes_by_root"), custody_by_root_requests: <_>::default(), components_by_range_requests: FnvHashMap::default(), custody_backfill_data_column_batch_requests: FnvHashMap::default(), @@ -331,7 +326,6 @@ impl SyncNetworkContext { blocks_by_range_requests, blobs_by_range_requests, data_columns_by_range_requests, - payload_envelopes_by_root_requests, // custody_by_root_requests is a meta request of data_columns_by_root_requests custody_by_root_requests: _, // components_by_range_requests is a meta request of various _by_range requests @@ -367,17 +361,12 @@ impl SyncNetworkContext { .active_requests_of_peer(peer_id) .into_iter() .map(|req_id| SyncRequestId::DataColumnsByRange(*req_id)); - let envelope_by_root_ids = payload_envelopes_by_root_requests - .active_requests_of_peer(peer_id) - .into_iter() - .map(|id| SyncRequestId::SinglePayloadEnvelope { id: *id }); blocks_by_root_ids .chain(blobs_by_root_ids) .chain(data_column_by_root_ids) .chain(blocks_by_range_ids) .chain(blobs_by_range_ids) .chain(data_column_by_range_ids) - .chain(envelope_by_root_ids) .collect() } @@ -434,7 +423,6 @@ impl SyncNetworkContext { blocks_by_range_requests, blobs_by_range_requests, data_columns_by_range_requests, - payload_envelopes_by_root_requests, // custody_by_root_requests is a meta request of data_columns_by_root_requests custody_by_root_requests: _, // components_by_range_requests is a meta request of various _by_range requests @@ -457,7 +445,6 @@ impl SyncNetworkContext { .chain(blocks_by_range_requests.iter_request_peers()) .chain(blobs_by_range_requests.iter_request_peers()) .chain(data_columns_by_range_requests.iter_request_peers()) - .chain(payload_envelopes_by_root_requests.iter_request_peers()) { *active_request_count_by_peer.entry(peer_id).or_default() += 1; } @@ -940,57 +927,6 @@ impl SyncNetworkContext { Ok(LookupRequestResult::RequestSent(id.req_id)) } - /// Request a payload envelope for `block_root` from a peer. - pub fn envelope_lookup_request( - &mut self, - lookup_id: SingleLookupId, - peer_id: PeerId, - block_root: Hash256, - ) -> Result { - let id = SingleLookupReqId { - lookup_id, - req_id: self.next_id(), - }; - - let request = PayloadEnvelopesByRootSingleRequest(block_root); - - let network_request = RequestType::PayloadEnvelopesByRoot( - request - .into_request(&self.fork_context) - .map_err(RpcRequestSendError::InternalError)?, - ); - self.network_send - .send(NetworkMessage::SendRequest { - peer_id, - request: network_request, - app_request_id: AppRequestId::Sync(SyncRequestId::SinglePayloadEnvelope { id }), - }) - .map_err(|_| RpcRequestSendError::InternalError("network send error".to_owned()))?; - - debug!( - method = "PayloadEnvelopesByRoot", - ?block_root, - peer = %peer_id, - %id, - "Sync RPC request sent" - ); - - let request_span = debug_span!( - parent: Span::current(), - "lh_outgoing_envelope_by_root_request", - %block_root, - ); - self.payload_envelopes_by_root_requests.insert( - id, - peer_id, - true, - PayloadEnvelopesByRootRequestItems::new(request), - request_span, - ); - - Ok(id.req_id) - } - /// Request necessary blobs for `block_root`. Requests only the necessary blobs by checking: /// - If we have a downloaded but not yet processed block /// - If the da_checker has a pending block @@ -1499,27 +1435,6 @@ impl SyncNetworkContext { self.on_rpc_response_result(resp, peer_id) } - pub(crate) fn on_single_envelope_response( - &mut self, - id: SingleLookupReqId, - peer_id: PeerId, - rpc_event: RpcEvent>>, - ) -> Option>>> { - let resp = self - .payload_envelopes_by_root_requests - .on_response(id, rpc_event); - let resp = resp.map(|res| { - res.and_then(|(mut envelopes, seen_timestamp)| { - match envelopes.pop() { - Some(envelope) => Ok((envelope, seen_timestamp)), - // Should never happen, request items enforces at least 1 chunk. - None => Err(LookupVerifyError::NotEnoughResponsesReturned { actual: 0 }.into()), - } - }) - }); - self.on_rpc_response_result(resp, peer_id) - } - pub(crate) fn on_single_blob_response( &mut self, id: SingleLookupReqId, @@ -1695,33 +1610,6 @@ impl SyncNetworkContext { }) } - pub fn send_envelope_for_processing( - &self, - id: Id, - envelope: Arc>, - seen_timestamp: Duration, - block_root: Hash256, - ) -> Result<(), SendErrorProcessor> { - let beacon_processor = self - .beacon_processor_if_enabled() - .ok_or(SendErrorProcessor::ProcessorNotAvailable)?; - - debug!(?block_root, ?id, "Sending payload envelope for processing"); - beacon_processor - .send_rpc_payload_envelope( - envelope, - seen_timestamp, - BlockProcessType::SinglePayloadEnvelope { id, block_root }, - ) - .map_err(|e| { - error!( - error = ?e, - "Failed to send sync envelope to processor" - ); - SendErrorProcessor::SendError - }) - } - pub fn send_blobs_for_processing( &self, id: Id, diff --git a/beacon_node/network/src/sync/network_context/requests.rs b/beacon_node/network/src/sync/network_context/requests.rs index 5b5e779d9b..8f9540693e 100644 --- a/beacon_node/network/src/sync/network_context/requests.rs +++ b/beacon_node/network/src/sync/network_context/requests.rs @@ -16,9 +16,6 @@ pub use data_columns_by_range::DataColumnsByRangeRequestItems; pub use data_columns_by_root::{ DataColumnsByRootRequestItems, DataColumnsByRootSingleBlockRequest, }; -pub use payload_envelopes_by_root::{ - PayloadEnvelopesByRootRequestItems, PayloadEnvelopesByRootSingleRequest, -}; use crate::metrics; @@ -30,7 +27,6 @@ mod blocks_by_range; mod blocks_by_root; mod data_columns_by_range; mod data_columns_by_root; -mod payload_envelopes_by_root; #[derive(Debug, PartialEq, Eq, IntoStaticStr)] pub enum LookupVerifyError { diff --git a/beacon_node/network/src/sync/network_context/requests/payload_envelopes_by_root.rs b/beacon_node/network/src/sync/network_context/requests/payload_envelopes_by_root.rs deleted file mode 100644 index 7f7097971d..0000000000 --- a/beacon_node/network/src/sync/network_context/requests/payload_envelopes_by_root.rs +++ /dev/null @@ -1,53 +0,0 @@ -use lighthouse_network::rpc::methods::PayloadEnvelopesByRootRequest; -use std::sync::Arc; -use types::{EthSpec, ForkContext, Hash256, SignedExecutionPayloadEnvelope}; - -use super::{ActiveRequestItems, LookupVerifyError}; - -#[derive(Debug, Copy, Clone)] -pub struct PayloadEnvelopesByRootSingleRequest(pub Hash256); - -impl PayloadEnvelopesByRootSingleRequest { - pub fn into_request( - self, - fork_context: &ForkContext, - ) -> Result { - PayloadEnvelopesByRootRequest::new(vec![self.0], fork_context) - } -} - -pub struct PayloadEnvelopesByRootRequestItems { - request: PayloadEnvelopesByRootSingleRequest, - items: Vec>>, -} - -impl PayloadEnvelopesByRootRequestItems { - pub fn new(request: PayloadEnvelopesByRootSingleRequest) -> Self { - Self { - request, - items: vec![], - } - } -} - -impl ActiveRequestItems for PayloadEnvelopesByRootRequestItems { - type Item = Arc>; - - /// Append a response to the single chunk request. If the chunk is valid, the request is - /// resolved immediately. - /// The active request SHOULD be dropped after `add_response` returns an error - fn add(&mut self, envelope: Self::Item) -> Result { - let beacon_block_root = envelope.beacon_block_root(); - if self.request.0 != beacon_block_root { - return Err(LookupVerifyError::UnrequestedBlockRoot(beacon_block_root)); - } - - self.items.push(envelope); - // Always returns true, payload envelopes by root expects a single response - Ok(true) - } - - fn consume(&mut self) -> Vec { - std::mem::take(&mut self.items) - } -}