Tree-sync friendly lookup sync tests

Makefile

@@ -31,8 +31,12 @@ TEST_FEATURES ?=
 PROFILE ?= release
 
 # List of all recent hard forks. This list is used to set env variables for http_api tests
+# Include phase0 to test the code paths in sync that are pre blobs
 RECENT_FORKS=electra fulu gloas
 
+# For network tests include phase0 to cover genesis syncing (blocks without blobs or columns)
+TEST_NETWORK_FORKS=phase0 $(RECENT_FORKS)
+
 # Extra flags for Cargo
 CARGO_INSTALL_EXTRA_FLAGS?=
 
@@ -219,10 +223,10 @@ test-op-pool-%:
 		-p operation_pool
 
 # Run the tests in the `network` crate for recent forks.
-test-network: $(patsubst %,test-network-%,$(RECENT_FORKS))
+test-network: $(patsubst %,test-network-%,$(TEST_NETWORK_FORKS))
 
 test-network-%:
-	env FORK_NAME=$* cargo nextest run --release \
+	env FORK_NAME=$* cargo nextest run --no-fail-fast --release \
 		--features "fork_from_env,$(TEST_FEATURES)" \
 		-p network
 

beacon_node/beacon_chain/Cargo.toml

@@ -1,4 +1,3 @@
-
 [package]
 name = "beacon_chain"
 version = "0.2.0"

beacon_node/beacon_chain/src/block_verification_types.rs

@@ -340,21 +340,6 @@ pub struct BlockImportData<E: EthSpec> {
     pub consensus_context: ConsensusContext<E>,
 }
 
-impl<E: EthSpec> BlockImportData<E> {
-    pub fn __new_for_test(
-        block_root: Hash256,
-        state: BeaconState<E>,
-        parent_block: SignedBeaconBlock<E, BlindedPayload<E>>,
-    ) -> Self {
-        Self {
-            block_root,
-            state,
-            parent_block,
-            consensus_context: ConsensusContext::new(Slot::new(0)),
-        }
-    }
-}
-
 /// Trait for common block operations.
 pub trait AsBlock<E: EthSpec> {
     fn slot(&self) -> Slot;

beacon_node/beacon_chain/src/builder.rs

@@ -977,7 +977,7 @@ where
 
         let beacon_chain = BeaconChain {
             spec: self.spec.clone(),
-            config: self.chain_config,
+            config: self.chain_config.clone(),
             store: store.clone(),
             task_executor: self
                 .task_executor
@@ -1051,6 +1051,7 @@ where
                     self.kzg.clone(),
                     store,
                     Arc::new(custody_context),
+                    &self.chain_config.test_config,
                     self.spec,
                 )
                 .map_err(|e| format!("Error initializing DataAvailabilityChecker: {:?}", e))?,

beacon_node/beacon_chain/src/chain_config.rs

@@ -121,6 +121,16 @@ pub struct ChainConfig {
     pub disable_get_blobs: bool,
     /// The node's custody type, determining how many data columns to custody and sample.
     pub node_custody_type: NodeCustodyType,
+    /// TESTING ONLY: Disable certain functionality to speed up tests
+    pub test_config: TestConfig,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, Clone, Deserialize, Serialize)]
+pub struct TestConfig {
+    /// FOR TESTING ONLY: Disable crypto verification to speed up tests
+    pub disable_crypto: bool,
+    /// FOR TESTING ONLY: Disable fetch_blobs optimization
+    pub disable_fetch_blobs: bool,
 }
 
 impl Default for ChainConfig {
@@ -162,6 +172,10 @@ impl Default for ChainConfig {
             invalid_block_roots: HashSet::new(),
             disable_get_blobs: false,
             node_custody_type: NodeCustodyType::Fullnode,
+            test_config: TestConfig {
+                disable_crypto: false,
+                disable_fetch_blobs: false,
+            },
         }
     }
 }

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -29,6 +29,7 @@ mod error;
 mod overflow_lru_cache;
 mod state_lru_cache;
 
+use crate::chain_config::TestConfig;
 use crate::data_availability_checker::error::Error;
 use crate::data_column_verification::{
     CustodyDataColumn, GossipVerifiedDataColumn, KzgVerifiedCustodyDataColumn,
@@ -86,6 +87,7 @@ pub struct DataAvailabilityChecker<T: BeaconChainTypes> {
     kzg: Arc<Kzg>,
     custody_context: Arc<CustodyContext<T::EthSpec>>,
     spec: Arc<ChainSpec>,
+    disable_crypto: bool,
 }
 
 pub type AvailabilityAndReconstructedColumns<E> = (Availability<E>, DataColumnSidecarList<E>);
@@ -124,6 +126,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         kzg: Arc<Kzg>,
         store: BeaconStore<T>,
         custody_context: Arc<CustodyContext<T::EthSpec>>,
+        test_config: &TestConfig,
         spec: Arc<ChainSpec>,
     ) -> Result<Self, AvailabilityCheckError> {
         let inner = DataAvailabilityCheckerInner::new(
@@ -139,6 +142,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             kzg,
             custody_context,
             spec,
+            disable_crypto: test_config.disable_crypto,
         })
     }
 
@@ -378,8 +382,10 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         let (block_root, block, blobs, data_columns) = block.deconstruct();
         if self.blobs_required_for_block(&block) {
             return if let Some(blob_list) = blobs {
-                verify_kzg_for_blob_list(blob_list.iter(), &self.kzg)
-                    .map_err(AvailabilityCheckError::InvalidBlobs)?;
+                if !self.disable_crypto {
+                    verify_kzg_for_blob_list(blob_list.iter(), &self.kzg)
+                        .map_err(AvailabilityCheckError::InvalidBlobs)?;
+                }
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
@@ -393,13 +399,15 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         }
         if self.data_columns_required_for_block(&block) {
             return if let Some(data_column_list) = data_columns.as_ref() {
-                verify_kzg_for_data_column_list(
-                    data_column_list
-                        .iter()
-                        .map(|custody_column| custody_column.as_data_column()),
-                    &self.kzg,
-                )
-                .map_err(AvailabilityCheckError::InvalidColumn)?;
+                if !self.disable_crypto {
+                    verify_kzg_for_data_column_list(
+                        data_column_list
+                            .iter()
+                            .map(|custody_column| custody_column.as_data_column()),
+                        &self.kzg,
+                    )
+                    .map_err(AvailabilityCheckError::InvalidColumn)?;
+                }
                 Ok(MaybeAvailableBlock::Available(AvailableBlock {
                     block_root,
                     block,
@@ -1195,6 +1203,7 @@ mod test {
             kzg,
             store,
             custody_context,
+            &TestConfig::default(),
             spec,
         )
         .expect("should initialise data availability checker")

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -727,6 +727,8 @@ impl<T: BeaconChainTypes> DataAvailabilityCheckerInner<T> {
     pub fn remove_pre_execution_block(&self, block_root: &Hash256) {
         // The read lock is immediately dropped so we can safely remove the block from the cache.
         if let Some(BlockProcessStatus::NotValidated(_, _)) = self.get_cached_block(block_root) {
+            // If the block is execution invalid, this status is permanent and idempotent to this
+            // block_root. We drop its components (e.g. columns) because they will never be useful.
             self.critical.write().pop(block_root);
         }
     }

beacon_node/beacon_chain/src/test_utils.rs

@@ -782,7 +782,13 @@ where
     }
 
     pub fn get_full_block(&self, block_root: &Hash256) -> RpcBlock<E> {
-        let block = self.chain.get_blinded_block(block_root).unwrap().unwrap();
+        let block = self
+            .chain
+            .get_blinded_block(block_root)
+            .unwrap()
+            .unwrap_or_else(|| {
+                panic!("block root does not exist in external harness {block_root:?}")
+            });
         let full_block = self.chain.store.make_full_block(block_root, block).unwrap();
         self.build_rpc_block_from_store_blobs(Some(*block_root), Arc::new(full_block))
     }

beacon_node/beacon_processor/src/lib.rs

@@ -446,12 +446,15 @@ impl<E: EthSpec> From<ReadyWork> for WorkEvent<E> {
                 },
             },
             ReadyWork::RpcBlock(QueuedRpcBlock {
-                beacon_block_root: _,
+                beacon_block_root,
                 process_fn,
                 ignore_fn: _,
             }) => Self {
                 drop_during_sync: false,
-                work: Work::RpcBlock { process_fn },
+                work: Work::RpcBlock {
+                    process_fn,
+                    beacon_block_root,
+                },
             },
             ReadyWork::IgnoredRpcBlock(IgnoredRpcBlock { process_fn }) => Self {
                 drop_during_sync: false,
@@ -592,6 +595,7 @@ pub enum Work<E: EthSpec> {
     GossipLightClientFinalityUpdate(BlockingFn),
     GossipLightClientOptimisticUpdate(BlockingFn),
     RpcBlock {
+        beacon_block_root: Hash256,
         process_fn: AsyncFn,
     },
     RpcBlobs {
@@ -674,7 +678,7 @@ pub enum WorkType {
 }
 
 impl<E: EthSpec> Work<E> {
-    fn str_id(&self) -> &'static str {
+    pub fn str_id(&self) -> &'static str {
         self.to_type().into()
     }
 
@@ -1592,7 +1596,10 @@ impl<E: EthSpec> BeaconProcessor<E> {
                 beacon_block_root: _,
                 process_fn,
             } => task_spawner.spawn_async(process_fn),
-            Work::RpcBlock { process_fn }
+            Work::RpcBlock {
+                process_fn,
+                beacon_block_root: _,
+            }
             | Work::RpcBlobs { process_fn }
             | Work::RpcCustodyColumn(process_fn)
             | Work::ColumnReconstruction(process_fn) => task_spawner.spawn_async(process_fn),

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -18,6 +18,7 @@ use ssz_types::VariableList;
 use std::cmp::max;
 use std::collections::HashMap;
 use std::sync::Arc;
+use tracing::warn;
 use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 use types::{
@@ -537,6 +538,21 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
                 .contains_key(&forkchoice_state.finalized_block_hash);
 
         if unknown_head_block_hash || unknown_safe_block_hash || unknown_finalized_block_hash {
+            if unknown_head_block_hash {
+                warn!(?head_block_hash, "Received unknown head block hash");
+            }
+            if unknown_safe_block_hash {
+                warn!(
+                    safe_block_hash = ?forkchoice_state.safe_block_hash,
+                    "Received unknown safe block hash"
+                );
+            }
+            if unknown_finalized_block_hash {
+                warn!(
+                    finalized_block_hash = ?forkchoice_state.finalized_block_hash,
+                    "Received unknown finalized block hash"
+                )
+            }
             return Ok(JsonForkchoiceUpdatedV1Response {
                 payload_status: JsonPayloadStatusV1 {
                     status: JsonPayloadStatusV1Status::Syncing,

beacon_node/execution_layer/src/test_utils/handle_rpc.rs

@@ -5,6 +5,7 @@ use crate::test_utils::{DEFAULT_CLIENT_VERSION, DEFAULT_MOCK_EL_PAYLOAD_VALUE_WE
 use serde::{Deserialize, de::DeserializeOwned};
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
+use tracing::debug;
 
 pub const GENERIC_ERROR_CODE: i64 = -1234;
 pub const BAD_PARAMS_ERROR_CODE: i64 = -32602;
@@ -28,6 +29,8 @@ pub async fn handle_rpc<E: EthSpec>(
         .ok_or_else(|| "missing/invalid params field".to_string())
         .map_err(|s| (s, GENERIC_ERROR_CODE))?;
 
+    debug!(method, "Mock execution engine");
+
     match method {
         ETH_SYNCING => ctx
             .syncing_response
@@ -517,6 +520,12 @@ pub async fn handle_rpc<E: EthSpec>(
                 _ => unreachable!(),
             };
 
+            debug!(
+                ?payload_attributes,
+                ?forkchoice_state,
+                "ENGINE_FORKCHOICE_UPDATED"
+            );
+
             // validate method called correctly according to fork time
             if let Some(pa) = payload_attributes.as_ref() {
                 match ctx
@@ -584,13 +593,15 @@ pub async fn handle_rpc<E: EthSpec>(
                 .lock()
                 .on_forkchoice_updated(forkchoice_state.clone(), payload_attributes.clone())
             {
+                debug!("Returning hook response");
                 return Ok(serde_json::to_value(hook_response).unwrap());
             }
 
             let head_block_hash = forkchoice_state.head_block_hash;
 
             // Canned responses set by block hash take priority.
             if let Some(status) = ctx.get_fcu_payload_status(&head_block_hash) {
+                debug!(?head_block_hash, "Canned response set by block hash");
                 return status
                     .map(|status| {
                         let response = JsonForkchoiceUpdatedV1Response {

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -715,7 +715,7 @@ where
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, IntoStaticStr)]
 pub enum RequestType<E: EthSpec> {
     Status(StatusMessage),
     Goodbye(GoodbyeReason),

beacon_node/lighthouse_network/src/service/api_types.rs

@@ -135,7 +135,7 @@ pub struct CustodyId {
 pub struct CustodyRequester(pub SingleLookupReqId);
 
 /// Application level requests sent to the network.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum AppRequestId {
     Sync(SyncRequestId),
     Router,

beacon_node/network/Cargo.toml

@@ -58,6 +58,7 @@ gossipsub = { workspace = true }
 k256 = "0.13.4"
 kzg = { workspace = true }
 matches = "0.1.8"
+paste = "1.0.15"
 rand_08 = { package = "rand", version = "0.8.5" }
 rand_chacha = "0.9.0"
 rand_chacha_03 = { package = "rand_chacha", version = "0.3.1" }

beacon_node/network/src/network_beacon_processor/mod.rs

@@ -440,7 +440,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         );
         self.try_send(BeaconWorkEvent {
             drop_during_sync: false,
-            work: Work::RpcBlock { process_fn },
+            work: Work::RpcBlock {
+                process_fn,
+                beacon_block_root: block_root,
+            },
         })
     }
 

beacon_node/network/src/network_beacon_processor/sync_methods.rs

@@ -224,8 +224,14 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 // derived from kzg commitments from the block, without having to wait for all blobs
                 // to be sent from the peers if we already have them.
                 let publish_blobs = false;
-                self.fetch_engine_blobs_and_publish(signed_beacon_block, block_root, publish_blobs)
-                    .await
+                if !self.chain.config.test_config.disable_fetch_blobs {
+                    self.fetch_engine_blobs_and_publish(
+                        signed_beacon_block,
+                        block_root,
+                        publish_blobs,
+                    )
+                    .await;
+                }
             }
             _ => {}
         }