More debug

pawanjay176 · pawanjay176 · commit 4f0b63d6edb8 · 2025-02-17T12:27:16.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,22 +14,22 @@ members = [
 
 [workspace.dependencies]
 async-trait = "0.1"
-axum = { version = "0.7", features = ["ws"] }
+axum = { version = "0.8", features = ["ws"] }
 bytes = "1.6"
-eth2 = { git = "https://github.com/sigp/lighthouse.git", rev = "df131b2a6c58609d3f772cd1ac89487a0d4247d0" }
+eth2 = { git = "https://github.com/sigp/lighthouse.git", rev = "897cab02a071ca8f35ce0b55aefc17617da2f14e" }
 ethereum_serde_utils = "0.7"
 ethereum_ssz = "0.7"
 ethereum_ssz_derive = "0.7"
 flate2 = "1.0"
 futures = "0.3.30"
-http = "1"
+http = "1.2"
 mediatype = "0.19.13"
-reqwest = { version = "0.12.5", features = ["json"] }
+reqwest = { version = "0.12.12", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1", features = ["raw_value"] }
 superstruct = "0.8"
 tokio = { version = "1", default-features = false, features = ["signal", "rt-multi-thread"] }
 tokio-tungstenite = "0.24.0"
 tracing = { version = "0.1", features = ["attributes"] }
-types = { git = "https://github.com/sigp/lighthouse.git", rev = "df131b2a6c58609d3f772cd1ac89487a0d4247d0" }
+types = { git = "https://github.com/sigp/lighthouse.git", rev = "897cab02a071ca8f35ce0b55aefc17617da2f14e" }
 rand = "0.8"
diff --git a/builder-server/Cargo.toml b/builder-server/Cargo.toml
@@ -17,3 +17,6 @@ serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true
 tracing.workspace = true
+
+[dev-dependencies]
+tower = "0.5.2"
diff --git a/builder-server/src/server.rs b/builder-server/src/server.rs
@@ -9,7 +9,8 @@ use axum::{
     Json, Router,
 };
 use builder_api_types::{
-    eth_spec::EthSpec, ExecutionBlockHash, PublicKeyBytes, SignedBlindedBeaconBlock,
+    eth_spec::EthSpec, fork_versioned_response::ForkVersionDecode, ExecutionBlockHash, ForkName,
+    FullPayloadContents, MainnetEthSpec, PublicKeyBytes, SignedBlindedBeaconBlock,
     SignedValidatorRegistrationData, Slot,
 };
 use ethereum_apis_common::{
@@ -40,7 +41,7 @@ where
         )
         .route("/eth/v1/builder/status", get(get_status))
         .route(
-            "/eth/v1/builder/header/:slot/:parent_hash/:pubkey",
+            "/eth/v1/builder/header/{slot}/{parent_hash}/{pubkey}",
             get(get_header::<I, A, E>),
         )
         .with_state(api_impl)
@@ -69,20 +70,22 @@ where
     I: AsRef<A> + Send + Sync,
     A: Builder<E>,
 {
+    dbg!(&headers);
     let content_type_header = headers.get(CONTENT_TYPE);
     let content_type = content_type_header.and_then(|value| value.to_str().ok());
     let content_type = match content_type {
         Some("application/octet-stream") => ContentType::Ssz,
         _ => ContentType::Json,
     };
     let slot = block.slot();
+
     let res = api_impl.as_ref().submit_blinded_block(block).await;
 
-    dbg!("in submit_blinded_block");
+    println!("in submit_blinded_block");
     let response =
         build_response_with_headers(res, content_type, api_impl.as_ref().fork_name_at_slot(slot))
             .await;
-    dbg!(&response);
+    println!("Got response ok {}", response.is_ok());
     response
 }
 
@@ -122,3 +125,110 @@ where
     tracing::info!("Got response from builder, constructing response");
     build_response_with_headers(res, content_type, api_impl.as_ref().fork_name_at_slot(slot)).await
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_trait::async_trait;
+    use axum::{body::Body, http::Request};
+    use builder_api_types::{
+        builder_bid::SignedBuilderBid, BeaconBlock, BeaconBlockDeneb, Blob, BlobsBundle,
+        EmptyBlock, ExecutionPayload, ExecutionPayloadAndBlobs, ExecutionPayloadDeneb, ForkName,
+        ForkVersionDecode, FullPayloadContents, KzgCommitment, KzgProof, MainnetEthSpec, Signature,
+    };
+    use ethereum_apis_common::{ErrorResponse, CONSENSUS_VERSION_HEADER};
+    use http::HeaderValue;
+    use ssz::Encode;
+    use std::{marker::PhantomData, usize};
+    use tower::ServiceExt;
+
+    #[derive(Clone)]
+    struct DummyBuilder<E: EthSpec> {
+        _phantom: PhantomData<E>,
+    }
+
+    impl<E: EthSpec> AsRef<DummyBuilder<E>> for DummyBuilder<E> {
+        fn as_ref(&self) -> &DummyBuilder<E> {
+            self
+        }
+    }
+
+    #[async_trait]
+    impl<E: EthSpec> Builder<E> for DummyBuilder<E> {
+        fn fork_name_at_slot(&self, _slot: Slot) -> builder_api_types::ForkName {
+            ForkName::Deneb
+        }
+
+        async fn get_header(
+            &self,
+            _slot: Slot,
+            _parent_hash: ExecutionBlockHash,
+            _pubkey: PublicKeyBytes,
+        ) -> Result<SignedBuilderBid<E>, ErrorResponse> {
+            todo!()
+        }
+
+        async fn register_validators(
+            &self,
+            _registrations: Vec<SignedValidatorRegistrationData>,
+        ) -> Result<(), ErrorResponse> {
+            Ok(())
+        }
+
+        async fn submit_blinded_block(
+            &self,
+            _block: SignedBlindedBeaconBlock<E>,
+        ) -> Result<FullPayloadContents<E>, ErrorResponse> {
+            let payload_and_blobs: ExecutionPayloadAndBlobs<E> = ExecutionPayloadAndBlobs {
+                blobs_bundle: BlobsBundle {
+                    commitments: vec![KzgCommitment::empty_for_testing()].into(),
+                    proofs: vec![KzgProof::empty()].into(),
+                    blobs: vec![Blob::<E>::new(vec![42; E::bytes_per_blob()]).unwrap()].into(),
+                },
+                execution_payload: ExecutionPayload::Deneb(ExecutionPayloadDeneb {
+                    ..Default::default()
+                }),
+            };
+            let full_payload = FullPayloadContents::PayloadAndBlobs(payload_and_blobs);
+            Ok(full_payload)
+        }
+    }
+
+    #[tokio::test]
+    async fn test_api() {
+        let app = new(DummyBuilder::<MainnetEthSpec> {
+            _phantom: PhantomData,
+        });
+
+        let spec = MainnetEthSpec::default_spec();
+        let dummy_block = SignedBlindedBeaconBlock::<MainnetEthSpec>::from_block(
+            BeaconBlock::Deneb(BeaconBlockDeneb::empty(&spec)),
+            Signature::empty(),
+        );
+        let request = Request::builder()
+            .uri("/eth/v1/builder/blinded_blocks")
+            .method("POST")
+            .header(
+                CONTENT_TYPE,
+                HeaderValue::from_static("application/octet-stream"),
+            )
+            .header(CONSENSUS_VERSION_HEADER, HeaderValue::from_static("deneb"))
+            .body(Body::from(dummy_block.as_ssz_bytes()))
+            .unwrap();
+
+        let response = app.oneshot(request).await.unwrap();
+
+        // Assert status code
+        // assert_eq!(response.status(), StatusCode::ACCEPTED);
+
+        // Get response body as bytes
+        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+            .await
+            .unwrap();
+
+        dbg!(
+            FullPayloadContents::<MainnetEthSpec>::from_ssz_bytes_by_fork(&body, ForkName::Deneb)
+                .unwrap()
+        );
+    }
+}
diff --git a/common/src/lib.rs b/common/src/lib.rs
@@ -1,5 +1,4 @@
 use axum::{
-    async_trait,
     body::Body,
     extract::{FromRequest, Request},
     response::{IntoResponse, Response},
@@ -32,10 +31,6 @@ where
 
     let resp = match result {
         Ok(body) => {
-            tracing::info!(
-                "Got a valid response from builder, content-type {:?}",
-                content_type
-            );
             println!(
                 "Got a valid response from builder, content-type {:?}",
                 content_type
@@ -59,40 +54,26 @@ where
                     })?,
                 );
             }
-
+            dbg!(&content_type);
             let body_content = match content_type {
                 ContentType::Json => {
                     let body = ForkVersionedResponse {
                         version: Some(fork_name),
                         metadata: EmptyMetadata {},
                         data: body,
                     };
-                    tokio::task::spawn_blocking(move || {
-                        serde_json::to_vec(&body).map_err(|e| {
-                            error!(error = ?e);
-                            StatusCode::INTERNAL_SERVER_ERROR
-                        })
-                    })
-                    .await
-                    .map_err(|e| {
+                    serde_json::to_vec(&body).map_err(|e| {
                         error!(error = ?e);
                         StatusCode::INTERNAL_SERVER_ERROR
-                    })??
+                    })?
                 }
-                ContentType::Ssz => tokio::task::spawn_blocking(move || T::as_ssz_bytes(&body))
-                    .await
-                    .map_err(|e| {
-                        error!(error = ?e);
-                        StatusCode::INTERNAL_SERVER_ERROR
-                    })?,
+
+                ContentType::Ssz => T::as_ssz_bytes(&body),
             };
-            dbg!(&body_content.len());
             let resp = response.body(Body::from(body_content)).map_err(|e| {
                 error!(error = ?e);
-                dbg!(&e);
                 StatusCode::INTERNAL_SERVER_ERROR
             });
-            dbg!(&resp);
             resp
         }
         Err(body) => {
@@ -208,7 +189,6 @@ where
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Ssz<T>(pub T);
 
-#[async_trait]
 impl<T, S> FromRequest<S> for Ssz<T>
 where
     T: ssz::Decode,
@@ -239,7 +219,6 @@ where
 #[derive(Debug, Clone, Copy, Default)]
 pub struct JsonOrSszWithFork<T>(pub T);
 
-#[async_trait]
 impl<T, S> FromRequest<S> for JsonOrSszWithFork<T>
 where
     T: serde::de::DeserializeOwned + ForkVersionDecode + 'static,
@@ -252,7 +231,6 @@ where
         let content_type = headers
             .get(CONTENT_TYPE)
             .and_then(|value| value.to_str().ok());
-        dbg!(&headers);
         let fork_name = headers
             .get(CONSENSUS_VERSION_HEADER)
             .and_then(|value| ForkName::from_str(value.to_str().unwrap()).ok());
@@ -283,7 +261,6 @@ where
 #[derive(Debug, Clone, Copy, Default)]
 pub struct JsonOrSsz<T>(pub T);
 
-#[async_trait]
 impl<T, S> FromRequest<S> for JsonOrSsz<T>
 where
     T: serde::de::DeserializeOwned + ssz::Decode + 'static,
@@ -323,7 +300,6 @@ where
 #[derive(Debug, Clone, Copy, Default)]
 pub struct JsonOrSszMaybeGzipped<T>(pub T);
 
-#[async_trait]
 impl<T, S> FromRequest<S> for JsonOrSszMaybeGzipped<T>
 where
     T: serde::de::DeserializeOwned + ssz::Decode + 'static,
@@ -447,7 +423,6 @@ pub fn custom_internal_err(message: String) -> ErrorResponse {
 #[derive(Debug, Clone, Copy, Default)]
 pub struct JsonConsensusVersionHeader<T>(pub T);
 
-#[async_trait]
 impl<T, S> FromRequest<S> for JsonConsensusVersionHeader<T>
 where
     T: ForkVersionDeserialize + 'static,
@@ -554,10 +529,10 @@ impl FromStr for Accept {
 
 #[cfg(test)]
 mod tests {
-    use std::usize;
+    // use std::usize;
 
     use super::*;
-    use axum::body::to_bytes;
+    // use axum::body::to_bytes;
     use beacon_api_types::{
         Blob, BlobsBundle, EthSpec, ExecutionPayload, ExecutionPayloadAndBlobs,
         ExecutionPayloadDeneb, FullPayloadContents, KzgCommitment, KzgProof, MainnetEthSpec,
@@ -585,9 +560,10 @@ mod tests {
         let resp = build_response_with_headers(Ok(full_payload), ContentType::Ssz, ForkName::Deneb)
             .await
             .unwrap();
-        let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
-        dbg!(&body.len());
-        FullPayloadContents::<MainnetEthSpec>::from_ssz_bytes_by_fork(&body, ForkName::Deneb)
-            .unwrap();
+        dbg!(&resp);
+        // let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+        // dbg!(&body.len());
+        // FullPayloadContents::<MainnetEthSpec>::from_ssz_bytes_by_fork(&body, ForkName::Deneb)
+        //     .unwrap();
     }
 }
