From 3523804515f9e05f8c1782152694d35a1951b0e5 Mon Sep 17 00:00:00 2001 From: Eitan Seri- Levi Date: Thu, 2 Apr 2026 19:30:12 -0700 Subject: [PATCH] cleanup --- .../src/beacon/execution_payload_envelope.rs | 15 ++++--- .../network/src/sync/block_lookups/mod.rs | 44 ++++++++++++++++++- beacon_node/network/src/sync/manager.rs | 38 +++++++++++++++- 3 files changed, 88 insertions(+), 9 deletions(-) diff --git a/beacon_node/http_api/src/beacon/execution_payload_envelope.rs b/beacon_node/http_api/src/beacon/execution_payload_envelope.rs index ea8c0d4b8a..7f81f7bf25 100644 --- a/beacon_node/http_api/src/beacon/execution_payload_envelope.rs +++ b/beacon_node/http_api/src/beacon/execution_payload_envelope.rs @@ -132,18 +132,21 @@ pub async fn publish_execution_payload_envelope( }; let ctx = chain.gossip_verification_context(); - let Ok(gossip_verifed_envelope) = GossipVerifiedEnvelope::new(signed_envelope, &ctx) else { - warn!(%slot, %beacon_block_root, "Execution payload envelope rejected"); - return Err(warp_utils::reject::custom_bad_request( - "execution payload envelope rejected, gossip verification".to_string(), - )); + let gossip_verified_envelope = match GossipVerifiedEnvelope::new(signed_envelope, &ctx) { + Ok(envelope) => envelope, + Err(e) => { + warn!(%slot, %beacon_block_root, error = ?e, "Execution payload envelope rejected"); + return Err(warp_utils::reject::custom_bad_request(format!( + "execution payload envelope rejected: {e:?}", + ))); + } }; // Import the envelope locally (runs state transition and notifies the EL). chain .process_execution_payload_envelope( beacon_block_root, - gossip_verifed_envelope, + gossip_verified_envelope, NotifyExecutionLayer::Yes, BlockImportSource::HttpApi, publish_fn, diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs index b33c38d147..4d14479627 100644 --- a/beacon_node/network/src/sync/block_lookups/mod.rs +++ b/beacon_node/network/src/sync/block_lookups/mod.rs @@ -228,6 +228,47 @@ impl BlockLookups { } } + /// A child block's parent envelope is missing. Create a child lookup (with the block component) + /// that waits for the parent envelope, and an envelope-only lookup for the parent. + /// + /// Returns true if both lookups are created or already exist. + #[must_use = "only reference the new lookup if returns true"] + pub fn search_child_and_parent_envelope( + &mut self, + block_root: Hash256, + block_component: BlockComponent, + parent_root: Hash256, + peer_id: PeerId, + cx: &mut SyncNetworkContext, + ) -> bool { + let envelope_lookup_exists = + self.search_parent_envelope_of_child(parent_root, &[peer_id], cx); + if envelope_lookup_exists { + // Create child lookup that waits for the parent envelope (not parent block). + // The child block itself is available, so we pass it as a component. + let child_created = self.new_current_lookup( + block_root, + Some(block_component), + None, // not awaiting parent block + &[], + cx, + ); + // Set awaiting_parent_envelope on the child lookup + if child_created { + if let Some((_, lookup)) = self + .single_block_lookups + .iter_mut() + .find(|(_, l)| l.is_for_block(block_root)) + { + lookup.set_awaiting_parent_envelope(parent_root); + } + } + child_created + } else { + false + } + } + /// Seach a block whose parent root is unknown. /// /// Returns true if the lookup is created or already exists @@ -815,7 +856,8 @@ impl BlockLookups { Action::ParentEnvelopeUnknown { parent_root } => { let peers = lookup.all_peers(); lookup.set_awaiting_parent_envelope(parent_root); - let envelope_lookup_exists = self.search_parent_envelope_of_child(parent_root, &peers, cx); + let envelope_lookup_exists = + self.search_parent_envelope_of_child(parent_root, &peers, cx); if envelope_lookup_exists { debug!( id = lookup_id, diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs index 2cc35081b7..1ca338ccd3 100644 --- a/beacon_node/network/src/sync/manager.rs +++ b/beacon_node/network/src/sync/manager.rs @@ -935,9 +935,9 @@ impl SyncManager { debug!( %block_root, %parent_root, - "Parent envelope not yet available, creating lookup" + "Parent envelope not yet available, creating envelope lookup" ); - self.handle_unknown_parent( + self.handle_unknown_parent_envelope( peer_id, block_root, parent_root, @@ -1055,6 +1055,40 @@ impl SyncManager { } } + /// Handle a block whose parent block is known but parent envelope is missing. + /// Creates an envelope-only lookup for the parent and a child lookup that waits for it. + fn handle_unknown_parent_envelope( + &mut self, + peer_id: PeerId, + block_root: Hash256, + parent_root: Hash256, + slot: Slot, + block_component: BlockComponent, + ) { + match self.should_search_for_block(Some(slot), &peer_id) { + Ok(_) => { + if self.block_lookups.search_child_and_parent_envelope( + block_root, + block_component, + parent_root, + peer_id, + &mut self.network, + ) { + // Lookups created + } else { + debug!( + ?block_root, + ?parent_root, + "No lookup created for child and parent envelope" + ); + } + } + Err(reason) => { + debug!(%block_root, %parent_root, reason, "Ignoring unknown parent envelope request"); + } + } + } + fn handle_unknown_block_root(&mut self, peer_id: PeerId, block_root: Hash256) { match self.should_search_for_block(None, &peer_id) { Ok(_) => {