Initial commit

Author: pawanjay176

beacon_node/builder_client/src/lib.rs

@@ -292,10 +292,25 @@ impl BuilderHttpClient {
         Ok(())
     }
 
-    /// `POST /eth/v1/builder/blinded_blocks` with SSZ serialized request body
     pub async fn post_builder_blinded_blocks_ssz<E: EthSpec>(
         &self,
         blinded_block: &SignedBlindedBeaconBlock<E>,
+    ) -> Result<Option<FullPayloadContents<E>>, Error> {
+        if blinded_block.fork_name_unchecked().fulu_enabled() {
+            self.post_builder_blinded_blocks_v2_ssz(blinded_block)
+                .await
+                .map(|_| None)
+        } else {
+            self.post_builder_blinded_blocks_v1_ssz(blinded_block)
+                .await
+                .map(Some)
+        }
+    }
+
+    /// `POST /eth/v1/builder/blinded_blocks` with SSZ serialized request body
+    pub async fn post_builder_blinded_blocks_v1_ssz<E: EthSpec>(
+        &self,
+        blinded_block: &SignedBlindedBeaconBlock<E>,
     ) -> Result<FullPayloadContents<E>, Error> {
         let mut path = self.server.full.clone();
 
@@ -340,10 +355,73 @@ impl BuilderHttpClient {
             .map_err(Error::InvalidSsz)
     }
 
-    /// `POST /eth/v1/builder/blinded_blocks`
+    /// `POST /eth/v2/builder/blinded_blocks` with SSZ serialized request body
+    pub async fn post_builder_blinded_blocks_v2_ssz<E: EthSpec>(
+        &self,
+        blinded_block: &SignedBlindedBeaconBlock<E>,
+    ) -> Result<(), Error> {
+        let mut path = self.server.full.clone();
+
+        let body = blinded_block.as_ssz_bytes();
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("eth")
+            .push("v2")
+            .push("builder")
+            .push("blinded_blocks");
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            CONSENSUS_VERSION_HEADER,
+            HeaderValue::from_str(&blinded_block.fork_name_unchecked().to_string())
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+        headers.insert(
+            CONTENT_TYPE_HEADER,
+            HeaderValue::from_str(SSZ_CONTENT_TYPE_HEADER)
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+        headers.insert(
+            ACCEPT,
+            HeaderValue::from_str(PREFERENCE_ACCEPT_VALUE)
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+
+        let result = self
+            .post_ssz_with_raw_response(
+                path,
+                body,
+                headers,
+                Some(self.timeouts.post_blinded_blocks),
+            )
+            .await?;
+
+        if result.status() == StatusCode::ACCEPTED {
+            Ok(())
+        } else {
+            // ACCEPTED is the only valid status code response
+            Err(Error::StatusCode(result.status()))
+        }
+    }
+
     pub async fn post_builder_blinded_blocks<E: EthSpec>(
         &self,
         blinded_block: &SignedBlindedBeaconBlock<E>,
+    ) -> Result<Option<ForkVersionedResponse<FullPayloadContents<E>>>, Error> {
+        if blinded_block.fork_name_unchecked().fulu_enabled() {
+            self.post_builder_blinded_blocks_v2(blinded_block)
+                .await
+                .map(|_| None)
+        } else {
+            self.post_builder_blinded_blocks_v1(blinded_block).await.map(Some)
+        }
+    }
+
+    /// `POST /eth/v1/builder/blinded_blocks`
+    pub async fn post_builder_blinded_blocks_v1<E: EthSpec>(
+        &self,
+        blinded_block: &SignedBlindedBeaconBlock<E>,
     ) -> Result<ForkVersionedResponse<FullPayloadContents<E>>, Error> {
         let mut path = self.server.full.clone();
 
@@ -383,6 +461,54 @@ impl BuilderHttpClient {
             .await?)
     }
 
+    /// `POST /eth/v2/builder/blinded_blocks`
+    pub async fn post_builder_blinded_blocks_v2<E: EthSpec>(
+        &self,
+        blinded_block: &SignedBlindedBeaconBlock<E>,
+    ) -> Result<(), Error> {
+        let mut path = self.server.full.clone();
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("eth")
+            .push("v2")
+            .push("builder")
+            .push("blinded_blocks");
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            CONSENSUS_VERSION_HEADER,
+            HeaderValue::from_str(&blinded_block.fork_name_unchecked().to_string())
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+        headers.insert(
+            CONTENT_TYPE_HEADER,
+            HeaderValue::from_str(JSON_CONTENT_TYPE_HEADER)
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+        headers.insert(
+            ACCEPT,
+            HeaderValue::from_str(JSON_ACCEPT_VALUE)
+                .map_err(|e| Error::InvalidHeaders(format!("{}", e)))?,
+        );
+
+        let result = self
+            .post_with_raw_response(
+                path,
+                &blinded_block,
+                headers,
+                Some(self.timeouts.post_blinded_blocks),
+            )
+            .await?;
+
+        if result.status() == StatusCode::ACCEPTED {
+            Ok(())
+        } else {
+            // ACCEPTED is the only valid status code response
+            Err(Error::StatusCode(result.status()))
+        }
+    }
+
     /// `GET /eth/v1/builder/header`
     pub async fn get_builder_header<E: EthSpec>(
         &self,

beacon_node/execution_layer/src/lib.rs

@@ -1893,7 +1893,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
         &self,
         block_root: Hash256,
         block: &SignedBlindedBeaconBlock<E>,
-    ) -> Result<FullPayloadContents<E>, Error> {
+    ) -> Result<Option<FullPayloadContents<E>>, Error> {
         debug!(?block_root, "Sending block to builder");
 
         if let Some(builder) = self.builder() {
@@ -1915,13 +1915,13 @@ impl<E: EthSpec> ExecutionLayer<E> {
                             .post_builder_blinded_blocks(block)
                             .await
                             .map_err(Error::Builder)
-                            .map(|d| d.data)
+                            .map(|d| d.map(|resp| resp.data))
                     }
                 })
                 .await;
 
             match &payload_result {
-                Ok(unblinded_response) => {
+                Ok(Some(unblinded_response)) => {
                     metrics::inc_counter_vec(
                         &metrics::EXECUTION_LAYER_BUILDER_REVEAL_PAYLOAD_OUTCOME,
                         &[metrics::SUCCESS],
@@ -1936,6 +1936,13 @@ impl<E: EthSpec> ExecutionLayer<E> {
                         "Builder successfully revealed payload"
                     )
                 }
+                Ok(None) => {
+                    info!(
+                        relay_response_ms = duration.as_millis(),
+                        ?block_root,
+                        "Builder returned a successful response"
+                    );
+                }
                 Err(e) => {
                     metrics::inc_counter_vec(
                         &metrics::EXECUTION_LAYER_BUILDER_REVEAL_PAYLOAD_OUTCOME,