Forward sync columns by root

beacon_node/lighthouse_network/src/peer_manager/peerdb.rs

@@ -327,6 +327,36 @@ impl<E: EthSpec> PeerDB<E> {
             .map(|(peer_id, _)| peer_id)
     }
 
+    /// Returns an iterator of all good gossipsub peers that are supposed to be custodying
+    /// the given subnet id and have the epoch according to their status messages.
+    pub fn good_custody_subnet_peer_range_sync(
+        &self,
+        subnet: DataColumnSubnetId,
+        epoch: Epoch,
+    ) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(move |(_, info)| {
+                // The custody_subnets hashset can be populated via enr or metadata
+                let is_custody_subnet_peer = info.is_assigned_to_custody_subnet(&subnet);
+
+                info.is_connected()
+                    && is_custody_subnet_peer
+                    && match info.sync_status() {
+                        SyncStatus::Synced { info } => {
+                            info.has_slot(epoch.end_slot(E::slots_per_epoch()))
+                        }
+                        SyncStatus::Advanced { info } => {
+                            info.has_slot(epoch.end_slot(E::slots_per_epoch()))
+                        }
+                        SyncStatus::IrrelevantPeer
+                        | SyncStatus::Behind { .. }
+                        | SyncStatus::Unknown => false,
+                    }
+            })
+            .map(|(peer_id, _)| peer_id)
+    }
+
     /// Checks if there is at least one good peer for each specified custody subnet for the given epoch.
     /// A "good" peer is one that is both connected and synced (or advanced) for the specified epoch.
     pub fn has_good_custody_range_sync_peer(

beacon_node/lighthouse_network/src/service/api_types.rs

@@ -38,6 +38,7 @@ pub enum SyncRequestId {
 pub struct DataColumnsByRootRequestId {
     pub id: Id,
     pub requester: DataColumnsByRootRequester,
+    pub peer: PeerId,
 }
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
@@ -46,6 +47,20 @@ pub struct BlocksByRangeRequestId {
     pub id: Id,
     /// The Id of the overall By Range request for block components.
     pub parent_request_id: ComponentsByRangeRequestId,
+    /// The peer that we made this request to
+    pub peer_id: PeerId,
+}
+
+impl BlocksByRangeRequestId {
+    pub fn batch_id(&self) -> Epoch {
+        match self.parent_request_id.requester {
+            RangeRequestId::BackfillSync { batch_id } => batch_id,
+            RangeRequestId::RangeSync {
+                chain_id: _,
+                batch_id,
+            } => batch_id,
+        }
+    }
 }
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
@@ -86,12 +101,24 @@ pub enum RangeRequestId {
     RangeSync { chain_id: Id, batch_id: Epoch },
     BackfillSync { batch_id: Epoch },
 }
+impl RangeRequestId {
+    pub fn batch_id(&self) -> Epoch {
+        match &self {
+            RangeRequestId::BackfillSync { batch_id } => *batch_id,
+            RangeRequestId::RangeSync {
+                chain_id: _,
+                batch_id,
+            } => *batch_id,
+        }
+    }
+}
 
 // TODO(das) refactor in a separate PR. We might be able to remove this and replace
 // [`DataColumnsByRootRequestId`] with a [`SingleLookupReqId`].
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum DataColumnsByRootRequester {
     Custody(CustodyId),
+    RangeSync { parent: ComponentsByRangeRequestId },
 }
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
@@ -222,6 +249,7 @@ impl Display for DataColumnsByRootRequester {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Custody(id) => write!(f, "Custody/{id}"),
+            Self::RangeSync { parent } => write!(f, "Range/{parent}"),
         }
     }
 }
@@ -255,6 +283,7 @@ mod tests {
                     lookup_id: 101,
                 }),
             }),
+            peer: PeerId::random(),
         };
         assert_eq!(format!("{id}"), "123/Custody/121/Lookup/101");
     }

beacon_node/network/src/network_beacon_processor/sync_methods.rs

@@ -1,6 +1,7 @@
 use crate::metrics::{self, register_process_result_metrics};
 use crate::network_beacon_processor::{FUTURE_SLOT_TOLERANCE, NetworkBeaconProcessor};
 use crate::sync::BatchProcessResult;
+use crate::sync::manager::FaultyComponent;
 use crate::sync::{
     ChainId,
     manager::{BlockProcessType, SyncMessage},
@@ -10,7 +11,8 @@ use beacon_chain::data_availability_checker::AvailabilityCheckError;
 use beacon_chain::data_availability_checker::MaybeAvailableBlock;
 use beacon_chain::{
     AvailabilityProcessingStatus, BeaconChainTypes, BlockError, ChainSegmentResult,
-    HistoricalBlockError, NotifyExecutionLayer, validator_monitor::get_slot_delay_ms,
+    ExecutionPayloadError, HistoricalBlockError, NotifyExecutionLayer,
+    validator_monitor::get_slot_delay_ms,
 };
 use beacon_processor::{
     AsyncFn, BlockingFn, DuplicateCache,
@@ -45,6 +47,8 @@ struct ChainSegmentFailed {
     message: String,
     /// Used to penalize peers.
     peer_action: Option<PeerAction>,
+    /// Used to identify the faulty component
+    faulty_component: Option<FaultyComponent>,
 }
 
 impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
@@ -492,6 +496,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                             Some(penalty) => BatchProcessResult::FaultyFailure {
                                 imported_blocks,
                                 penalty,
+                                faulty_component: e.faulty_component,
                             },
                             None => BatchProcessResult::NonFaultyFailure,
                         }
@@ -543,6 +548,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                             Some(penalty) => BatchProcessResult::FaultyFailure {
                                 imported_blocks: 0,
                                 penalty,
+                                faulty_component: e.faulty_component,
                             },
                             None => BatchProcessResult::NonFaultyFailure,
                         }
@@ -614,15 +620,18 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         Err(ChainSegmentFailed {
                             peer_action: None,
                             message: "Failed to check block availability".into(),
+                            faulty_component: None,
                         }),
                     );
                 }
+
                 e => {
                     return (
                         0,
                         Err(ChainSegmentFailed {
                             peer_action: Some(PeerAction::LowToleranceError),
                             message: format!("Failed to check block availability : {:?}", e),
+                            faulty_component: None, // Todo(pawan): replicate behaviour in forward sync once its proven
                         }),
                     );
                 }
@@ -639,6 +648,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         (total_blocks - available_blocks.len()),
                         total_blocks
                     ),
+                    faulty_component: Some(FaultyComponent::Blocks),
                 }),
             );
         }
@@ -654,7 +664,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 metrics::inc_counter(
                     &metrics::BEACON_PROCESSOR_BACKFILL_CHAIN_SEGMENT_FAILED_TOTAL,
                 );
-                let peer_action = match &e {
+                let (peer_action, faulty_component) = match &e {
                     HistoricalBlockError::MismatchedBlockRoot {
                         block_root,
                         expected_block_root,
@@ -666,7 +676,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                             "Backfill batch processing error"
                         );
                         // The peer is faulty if they send blocks with bad roots.
-                        Some(PeerAction::LowToleranceError)
+                        (
+                            Some(PeerAction::LowToleranceError),
+                            Some(FaultyComponent::Blocks),
+                        )
                     }
                     HistoricalBlockError::InvalidSignature
                     | HistoricalBlockError::SignatureSet(_) => {
@@ -675,28 +688,31 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                             "Backfill batch processing error"
                         );
                         // The peer is faulty if they bad signatures.
-                        Some(PeerAction::LowToleranceError)
+                        (
+                            Some(PeerAction::LowToleranceError),
+                            Some(FaultyComponent::Blocks),
+                        )
                     }
                     HistoricalBlockError::ValidatorPubkeyCacheTimeout => {
                         warn!(
                             error = "pubkey_cache_timeout",
                             "Backfill batch processing error"
                         );
                         // This is an internal error, do not penalize the peer.
-                        None
+                        (None, None)
                     }
                     HistoricalBlockError::IndexOutOfBounds => {
                         error!(
                             error = ?e,
                             "Backfill batch OOB error"
                         );
                         // This should never occur, don't penalize the peer.
-                        None
+                        (None, None)
                     }
                     HistoricalBlockError::StoreError(e) => {
                         warn!(error = ?e, "Backfill batch processing error");
                         // This is an internal error, don't penalize the peer.
-                        None
+                        (None, None)
                     } //
                       // Do not use a fallback match, handle all errors explicitly
                 };
@@ -707,6 +723,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         message: format!("{:?}", err_str),
                         // This is an internal error, don't penalize the peer.
                         peer_action,
+                        faulty_component,
                     }),
                 )
             }
@@ -721,7 +738,8 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 Err(ChainSegmentFailed {
                     message: format!("Block has an unknown parent: {}", parent_root),
                     // Peers are faulty if they send non-sequential blocks.
-                    peer_action: Some(PeerAction::LowToleranceError),
+                    peer_action: Some(PeerAction::LowToleranceError), // todo(pawan): revise this
+                    faulty_component: Some(FaultyComponent::Blocks),
                 })
             }
             BlockError::DuplicateFullyImported(_)
@@ -760,6 +778,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     ),
                     // Peers are faulty if they send blocks from the future.
                     peer_action: Some(PeerAction::LowToleranceError),
+                    faulty_component: Some(FaultyComponent::Blocks),
                 })
             }
             BlockError::WouldRevertFinalizedSlot { .. } => {
@@ -776,6 +795,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         block_parent_root
                     ),
                     peer_action: Some(PeerAction::Fatal),
+                    faulty_component: Some(FaultyComponent::Blocks),
                 })
             }
             BlockError::GenesisBlock => {
@@ -793,10 +813,24 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     message: format!("Internal error whilst processing block: {:?}", e),
                     // Do not penalize peers for internal errors.
                     peer_action: None,
+                    faulty_component: None,
                 })
             }
             ref err @ BlockError::ExecutionPayloadError(ref epe) => {
-                if !epe.penalize_peer() {
+                if matches!(epe, ExecutionPayloadError::RejectedByExecutionEngine { .. }) {
+                    debug!(
+                        error = ?err,
+                        "Invalid execution payload rejected by EE"
+                    );
+                    Err(ChainSegmentFailed {
+                        message: format!(
+                            "Peer sent a block containing invalid execution payload. Reason: {:?}",
+                            err
+                        ),
+                        peer_action: Some(PeerAction::LowToleranceError),
+                        faulty_component: Some(FaultyComponent::Blocks), // todo(pawan): recheck this
+                    })
+                } else if !epe.penalize_peer() {
                     // These errors indicate an issue with the EL and not the `ChainSegment`.
                     // Pause the syncing while the EL recovers
                     debug!(
@@ -808,6 +842,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         message: format!("Execution layer offline. Reason: {:?}", err),
                         // Do not penalize peers for internal errors.
                         peer_action: None,
+                        faulty_component: None,
                     })
                 } else {
                     debug!(
@@ -820,6 +855,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                             err
                         ),
                         peer_action: Some(PeerAction::LowToleranceError),
+                        faulty_component: Some(FaultyComponent::Blocks),
                     })
                 }
             }
@@ -835,6 +871,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     // of a faulty EL it will usually require manual intervention to fix anyway, so
                     // it's not too bad if we drop most of our peers.
                     peer_action: Some(PeerAction::LowToleranceError),
+                    faulty_component: Some(FaultyComponent::Blocks),
                 })
             }
             // Penalise peers for sending us banned blocks.
@@ -843,8 +880,49 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 Err(ChainSegmentFailed {
                     message: format!("Banned block: {block_root:?}"),
                     peer_action: Some(PeerAction::Fatal),
+                    faulty_component: Some(FaultyComponent::Blocks),
                 })
             }
+            ref err @ BlockError::AvailabilityCheck(ref e) => {
+                match &e {
+                    AvailabilityCheckError::InvalidBlobs(_)
+                    | AvailabilityCheckError::BlobIndexInvalid(_) => Err(ChainSegmentFailed {
+                        message: format!("Peer sent invalid blobs. Reason: {:?}", err),
+                        // Do not penalize peers for internal errors.
+                        peer_action: Some(PeerAction::LowToleranceError),
+                        faulty_component: Some(FaultyComponent::Blobs),
+                    }),
+                    AvailabilityCheckError::InvalidColumn((column_opt, _)) => {
+                        let (peer_action, faulty_component) = if let Some(column) = column_opt {
+                            (
+                                Some(PeerAction::LowToleranceError),
+                                Some(FaultyComponent::Columns(vec![*column])),
+                            )
+                        } else {
+                            (None, None)
+                        };
+                        Err(ChainSegmentFailed {
+                            message: format!("Peer sent invalid columns. Reason: {:?}", err),
+                            peer_action,
+                            faulty_component,
+                        })
+                    }
+                    AvailabilityCheckError::DataColumnIndexInvalid(column) => {
+                        Err(ChainSegmentFailed {
+                            message: format!("Peer sent invalid columns. Reason: {:?}", err),
+                            // Do not penalize peers for internal errors.
+                            peer_action: Some(PeerAction::LowToleranceError),
+                            faulty_component: Some(FaultyComponent::Columns(vec![*column])),
+                        })
+                    }
+                    _ => Err(ChainSegmentFailed {
+                        message: format!("Peer sent invalid block. Reason: {:?}", err),
+                        // Do not penalize peers for internal errors.
+                        peer_action: None,
+                        faulty_component: None,
+                    }),
+                }
+            }
             other => {
                 debug!(
                     msg = "peer sent invalid block",
@@ -856,6 +934,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     message: format!("Peer sent invalid block. Reason: {:?}", other),
                     // Do not penalize peers for internal errors.
                     peer_action: None,
+                    faulty_component: None,
                 })
             }
         }