Fix PeerDAS sync scoring (#7352)

* Remove request tracking inside syncing chains

* Prioritize by range peers in network context

* Prioritize custody peers for columns by range

* Explicit error handling of the no peers error case

* Remove good_peers_on_sampling_subnets

* Count AwaitingDownload towards the buffer limit

* Retry syncing chains in AwaitingDownload state

* Use same peer priorization for lookups

* Review PR

* Address TODOs

* Revert changes to peer erroring in range sync

* Revert metrics changes

* Update comment

* Pass peers_to_deprioritize to select_columns_by_range_peers_to_request

* more idiomatic

* Idiomatic while

* Add note about infinite loop

* Use while let

* Fix wrong custody column count for lookup blocks

* Remove impl

* Remove stale comment

* Fix build errors.

* Or default

* Review PR

* BatchPeerGroup

* Match block and blob signatures

* Explicit match statement to BlockError in range sync

* Remove todo in BatchPeerGroup

* Remove participating peers from backfill sync

* Remove MissingAllCustodyColumns error

* Merge fixes

* Clean up PR

* Consistent naming of batch_peers

* Address multiple review comments

* Better errors for das

* Penalize column peers once

* Restore fn

* Fix error enum

* Removed MismatchedPublicKeyLen

* Revert testing changes

* Change BlockAndCustodyColumns enum variant

* Revert type change in import_historical_block_batch

* Drop pubkey cache

* Don't collect Vec

* Classify errors

* Remove ReconstructColumnsError

* More detailed UnrequestedSlot error

* Lint test

* Fix slot conversion

* Reduce penalty for missing blobs

* Revert changes in peer selection

* Lint tests

* Rename block matching functions

* Reorder block matching in historical blocks

* Fix order of block matching

* Add store tests

* Filter blockchain in assert_correct_historical_block_chain

* Also filter before KZG checks

* Lint tests

* Fix lint

* Fix fulu err assertion

* Check point is not at infinity

* Fix ws sync test

* Revert dropping filter fn

---------

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>
Co-authored-by: Jimmy Chen <jimmy@sigmaprime.io>
Co-authored-by: Pawan Dhananjay <pawandhananjay@gmail.com>

beacon_node/beacon_chain/src/data_availability_checker/error.rs

@@ -1,24 +1,20 @@
 use kzg::{Error as KzgError, KzgCommitment};
-use types::{BeaconStateError, ColumnIndex, Hash256};
+use types::{BeaconStateError, ColumnIndex};
 
 #[derive(Debug)]
 pub enum Error {
     InvalidBlobs(KzgError),
     InvalidColumn(Vec<(ColumnIndex, KzgError)>),
-    ReconstructColumnsError(KzgError),
     KzgCommitmentMismatch {
         blob_commitment: KzgCommitment,
         block_commitment: KzgCommitment,
     },
     Unexpected(String),
-    SszTypes(ssz_types::Error),
     MissingBlobs,
-    MissingCustodyColumns,
+    MissingCustodyColumns(Vec<ColumnIndex>),
     BlobIndexInvalid(u64),
     DataColumnIndexInvalid(u64),
     StoreError(store::Error),
-    DecodeError(ssz::DecodeError),
-    ParentStateMissing(Hash256),
     BlockReplayError(state_processing::BlockReplayError),
     RebuildingStateCaches(BeaconStateError),
     SlotClockError,
@@ -35,19 +31,15 @@ pub enum ErrorCategory {
 impl Error {
     pub fn category(&self) -> ErrorCategory {
         match self {
-            Error::SszTypes(_)
-            | Error::MissingBlobs
-            | Error::MissingCustodyColumns
-            | Error::StoreError(_)
-            | Error::DecodeError(_)
+            Error::StoreError(_)
             | Error::Unexpected(_)
-            | Error::ParentStateMissing(_)
             | Error::BlockReplayError(_)
             | Error::RebuildingStateCaches(_)
             | Error::SlotClockError => ErrorCategory::Internal,
-            Error::InvalidBlobs { .. }
+            Error::MissingBlobs
+            | Error::MissingCustodyColumns(_)
+            | Error::InvalidBlobs { .. }
             | Error::InvalidColumn { .. }
-            | Error::ReconstructColumnsError { .. }
             | Error::BlobIndexInvalid(_)
             | Error::DataColumnIndexInvalid(_)
             | Error::KzgCommitmentMismatch { .. } => ErrorCategory::Malicious,
@@ -55,24 +47,12 @@ impl Error {
     }
 }
 
-impl From<ssz_types::Error> for Error {
-    fn from(value: ssz_types::Error) -> Self {
-        Self::SszTypes(value)
-    }
-}
-
 impl From<store::Error> for Error {
     fn from(value: store::Error) -> Self {
         Self::StoreError(value)
     }
 }
 
-impl From<ssz::DecodeError> for Error {
-    fn from(value: ssz::DecodeError) -> Self {
-        Self::DecodeError(value)
-    }
-}
-
 impl From<state_processing::BlockReplayError> for Error {
     fn from(value: state_processing::BlockReplayError) -> Self {
         Self::BlockReplayError(value)

beacon_node/beacon_chain/src/data_availability_checker/state_lru_cache.rs

@@ -157,9 +157,9 @@ impl<T: BeaconChainTypes> StateLRUCache<T> {
                 parent_block_state_root,
             )
             .map_err(AvailabilityCheckError::StoreError)?
-            .ok_or(AvailabilityCheckError::ParentStateMissing(
-                parent_block_state_root,
-            ))?;
+            .ok_or(AvailabilityCheckError::Unexpected(format!(
+                "Parent state missing {parent_block_state_root:?}"
+            )))?;
 
         let state_roots = vec![
             Ok((parent_state_root, diet_executed_block.parent_block.slot())),