Fix http api tests ci (#7943)

Co-Authored-By: Jimmy Chen <[email protected]>

Co-Authored-By: Michael Sproul <[email protected]>

Co-Authored-By: Michael Sproul <[email protected]>

Co-Authored-By: hopinheimer <[email protected]>

Author: hopinheimer

Makefile

@@ -193,11 +193,11 @@ test-beacon-chain: $(patsubst %,test-beacon-chain-%,$(FORKS))
 test-beacon-chain-%:
 	env FORK_NAME=$* cargo nextest run --release --features "fork_from_env,slasher/lmdb,$(TEST_FEATURES)" -p beacon_chain
 
-# Run the tests in the `beacon_chain` crate for all known forks.
-test-http-api: $(patsubst %,test-beacon-chain-%,$(RECENT_FORKS))
+# Run the tests in the `http_api` crate for recent forks.
+test-http-api: $(patsubst %,test-http-api-%,$(RECENT_FORKS))
 
 test-http-api-%:
-	env FORK_NAME=$* cargo nextest run --release --features "fork_from_env,slasher/lmdb,$(TEST_FEATURES)" -p http_api
+	env FORK_NAME=$* cargo nextest run --release --features "beacon_chain/fork_from_env" -p http_api
 
 
 # Run the tests in the `operation_pool` crate for all known forks.

beacon_node/beacon_chain/src/blob_verification.rs

@@ -96,7 +96,7 @@ pub enum GossipBlobError {
     /// ## Peer scoring
     ///
     /// We cannot process the blob without validating its parent, the peer isn't necessarily faulty.
-    BlobParentUnknown { parent_root: Hash256 },
+    ParentUnknown { parent_root: Hash256 },
 
     /// Invalid kzg commitment inclusion proof
     /// ## Peer scoring
@@ -474,7 +474,7 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes, O: ObservationStrat
     // We have already verified that the blob is past finalization, so we can
     // just check fork choice for the block's parent.
     let Some(parent_block) = fork_choice.get_block(&block_parent_root) else {
-        return Err(GossipBlobError::BlobParentUnknown {
+        return Err(GossipBlobError::ParentUnknown {
             parent_root: block_parent_root,
         });
     };

beacon_node/beacon_chain/src/test_utils.rs

@@ -715,7 +715,10 @@ where
     pub fn set_mock_builder(
         &mut self,
         beacon_url: SensitiveUrl,
-    ) -> impl futures::Future<Output = ()> + 'static {
+        strict_registrations: bool,
+        apply_operations: bool,
+        broadcast_to_bn: bool,
+    ) -> impl futures::Future<Output = ()> + use<E, Hot, Cold> {
         let mock_el = self
             .mock_execution_layer
             .as_ref()
@@ -727,6 +730,9 @@ where
         let (mock_builder, (addr, mock_builder_server)) = MockBuilder::new_for_testing(
             mock_el_url,
             beacon_url,
+            strict_registrations,
+            apply_operations,
+            broadcast_to_bn,
             self.spec.clone(),
             self.runtime.task_executor.clone(),
         );
@@ -903,8 +909,65 @@ where
         state: BeaconState<E>,
         slot: Slot,
     ) -> (SignedBlindedBeaconBlock<E>, BeaconState<E>) {
-        let (unblinded, new_state) = self.make_block(state, slot).await;
-        ((*unblinded.0).clone().into(), new_state)
+        self.make_blinded_block_with_modifier(state, slot, |_| {})
+            .await
+    }
+
+    pub async fn make_blinded_block_with_modifier(
+        &self,
+        mut state: BeaconState<E>,
+        slot: Slot,
+        block_modifier: impl FnOnce(&mut BlindedBeaconBlock<E>),
+    ) -> (SignedBlindedBeaconBlock<E>, BeaconState<E>) {
+        assert_ne!(slot, 0, "can't produce a block at slot 0");
+        assert!(slot >= state.slot());
+
+        complete_state_advance(&mut state, None, slot, &self.spec)
+            .expect("should be able to advance state to slot");
+
+        state.build_caches(&self.spec).expect("should build caches");
+
+        let proposer_index = state.get_beacon_proposer_index(slot, &self.spec).unwrap();
+
+        // If we produce two blocks for the same slot, they hash up to the same value and
+        // BeaconChain errors out with `DuplicateFullyImported`.  Vary the graffiti so that we produce
+        // different blocks each time.
+        let graffiti = Graffiti::from(self.rng.lock().random::<[u8; 32]>());
+
+        let randao_reveal = self.sign_randao_reveal(&state, proposer_index, slot);
+
+        // Always use the builder, so that we produce a "real" blinded payload.
+        let builder_boost_factor = Some(u64::MAX);
+
+        let BeaconBlockResponseWrapper::Blinded(block_response) = self
+            .chain
+            .produce_block_on_state(
+                state,
+                None,
+                slot,
+                randao_reveal,
+                Some(graffiti),
+                ProduceBlockVerification::VerifyRandao,
+                builder_boost_factor,
+                BlockProductionVersion::V3,
+            )
+            .await
+            .unwrap()
+        else {
+            panic!("Should always be a blinded payload response");
+        };
+
+        let mut block = block_response.block;
+        block_modifier(&mut block);
+
+        let signed_block = block.sign(
+            &self.validator_keypairs[proposer_index].sk,
+            &block_response.state.fork(),
+            block_response.state.genesis_validators_root(),
+            &self.spec,
+        );
+
+        (signed_block, block_response.state)
     }
 
     /// Returns a newly created block, signed by the proposer for the given slot.

beacon_node/builder_client/src/lib.rs

@@ -8,7 +8,7 @@ use eth2::types::{
 use eth2::types::{FullPayloadContents, SignedBlindedBeaconBlock};
 use eth2::{
     CONSENSUS_VERSION_HEADER, CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE_HEADER,
-    SSZ_CONTENT_TYPE_HEADER, StatusCode, ok_or_error,
+    SSZ_CONTENT_TYPE_HEADER, StatusCode, ok_or_error, success_or_error,
 };
 use reqwest::header::{ACCEPT, HeaderMap, HeaderValue};
 use reqwest::{IntoUrl, Response};
@@ -249,7 +249,7 @@ impl BuilderHttpClient {
             .send()
             .await
             .map_err(Error::from)?;
-        ok_or_error(response).await
+        success_or_error(response).await
     }
 
     async fn post_with_raw_response<T: Serialize, U: IntoUrl>(
@@ -270,7 +270,7 @@ impl BuilderHttpClient {
             .send()
             .await
             .map_err(Error::from)?;
-        ok_or_error(response).await
+        success_or_error(response).await
     }
 
     /// `POST /eth/v1/builder/validators`

beacon_node/execution_layer/src/lib.rs

@@ -2032,7 +2032,9 @@ impl<E: EthSpec> ExecutionLayer<E> {
                         relay_response_ms = duration.as_millis(),
                         ?block_root,
                         "Successfully submitted blinded block to the builder"
-                    )
+                    );
+
+                    Ok(())
                 }
                 Err(e) => {
                     metrics::inc_counter_vec(
@@ -2045,11 +2047,10 @@ impl<E: EthSpec> ExecutionLayer<E> {
                         relay_response_ms = duration.as_millis(),
                         ?block_root,
                         "Failed to submit blinded block to the builder"
-                    )
+                    );
+                    Err(e)
                 }
             }
-
-            Ok(())
         } else {
             Err(Error::NoPayloadBuilder)
         }