fix test

Author: ltitanb

Cargo.lock

@@ -23,17 +23,23 @@ pub type PayloadAndBlobs = lh_eth2::types::ExecutionPayloadAndBlobs<MainnetEthSp
 pub type SubmitBlindedBlockResponse = lh_types::ForkVersionedResponse<PayloadAndBlobs>;
 
 pub type ExecutionPayloadHeader = lh_types::ExecutionPayloadHeader<MainnetEthSpec>;
+pub type ExecutionPayloadHeaderElectra = lh_types::ExecutionPayloadHeaderElectra<MainnetEthSpec>;
+pub type ExecutionPayloadHeaderFulu = lh_types::ExecutionPayloadHeaderFulu<MainnetEthSpec>;
 pub type ExecutionPayloadHeaderRef<'a> = lh_types::ExecutionPayloadHeaderRef<'a, MainnetEthSpec>;
 pub type ExecutionPayload = lh_types::ExecutionPayload<MainnetEthSpec>;
 pub type ExecutionPayloadElectra = lh_types::ExecutionPayloadElectra<MainnetEthSpec>;
 pub type ExecutionPayloadFulu = lh_types::ExecutionPayloadFulu<MainnetEthSpec>;
 pub type SignedBuilderBid = lh_types::builder_bid::SignedBuilderBid<MainnetEthSpec>;
+pub type BuilderBid = lh_types::builder_bid::BuilderBid<MainnetEthSpec>;
+pub type BuilderBidElectra = lh_types::builder_bid::BuilderBidElectra<MainnetEthSpec>;
 
 /// Response object of GET
 /// `/eth/v1/builder/header/{slot}/{parent_hash}/{pubkey}`
 pub type GetHeaderResponse = lh_types::ForkVersionedResponse<SignedBuilderBid>;
 
-pub use lh_types::ForkVersionedResponse;
+pub use lh_types::{ForkName, ForkVersionedResponse};
+
+pub type ExecutionRequests = lh_types::execution_requests::ExecutionRequests<MainnetEthSpec>;
 
 /// Response params of GET
 /// `/eth/v1/builder/header/{slot}/{parent_hash}/{pubkey}`

crates/common/src/pbs/types/mod.rs

@@ -11,6 +11,7 @@ cb-common.workspace = true
 cb-pbs.workspace = true
 cb-signer.workspace = true
 eyre.workspace = true
+lh_types.workspace = true
 reqwest.workspace = true
 serde_json.workspace = true
 tempfile.workspace = true

tests/Cargo.toml

@@ -16,15 +16,18 @@ use axum::{
 };
 use cb_common::{
     pbs::{
-        BUILDER_V1_API_PATH, BUILDER_V2_API_PATH, BlindedBeaconBlock, GET_HEADER_PATH,
-        GET_STATUS_PATH, GetHeaderParams, GetHeaderResponse, REGISTER_VALIDATOR_PATH,
-        SUBMIT_BLOCK_PATH, SignedBlindedBeaconBlock, SubmitBlindedBlockResponse,
+        BUILDER_V1_API_PATH, BUILDER_V2_API_PATH, BlobsBundle, BuilderBid, BuilderBidElectra,
+        ExecutionPayloadElectra, ExecutionPayloadHeaderElectra, ExecutionRequests, ForkName,
+        GET_HEADER_PATH, GET_STATUS_PATH, GetHeaderParams, GetHeaderResponse, GetPyloadInfo,
+        PayloadAndBlobs, REGISTER_VALIDATOR_PATH, SUBMIT_BLOCK_PATH, SignedBlindedBeaconBlock,
+        SignedBuilderBid, SubmitBlindedBlockResponse,
     },
     signature::sign_builder_root,
     types::{BlsSecretKey, Chain},
-    utils::timestamp_of_slot_start_sec,
+    utils::{TestRandomSeed, timestamp_of_slot_start_sec},
 };
 use cb_pbs::MAX_SIZE_SUBMIT_BLOCK_RESPONSE;
+use lh_types::KzgProof;
 use tokio::net::TcpListener;
 use tracing::debug;
 use tree_hash::TreeHash;
@@ -110,25 +113,32 @@ async fn handle_get_header(
 ) -> Response {
     state.received_get_header.fetch_add(1, Ordering::Relaxed);
 
-    let mut message = ExecutionPayloadHeaderMessageElectra {
-        header: Default::default(),
-        blob_kzg_commitments: Default::default(),
-        execution_requests: ExecutionRequests::default(),
-        value: Default::default(),
-        pubkey: state.signer.public_key(),
+    let mut header = ExecutionPayloadHeaderElectra {
+        parent_hash: parent_hash.into(),
+        block_hash: Default::default(),
+        timestamp: timestamp_of_slot_start_sec(0, state.chain),
+        ..ExecutionPayloadHeaderElectra::test_random()
     };
 
-    message.header.parent_hash = parent_hash;
-    message.header.block_hash.0[0] = 1;
-    message.value = U256::from(10);
-    message.pubkey = state.signer.public_key();
-    message.header.timestamp = timestamp_of_slot_start_sec(0, state.chain);
+    header.block_hash.0[0] = 1;
+
+    let message = BuilderBid::Electra(BuilderBidElectra {
+        header,
+        blob_kzg_commitments: Default::default(),
+        execution_requests: ExecutionRequests::default(),
+        value: U256::from(10),
+        pubkey: state.signer.public_key().into(),
+    });
 
     let object_root = message.tree_hash_root();
     let signature = sign_builder_root(state.chain, &state.signer, object_root);
-    let response = SignedExecutionPayloadHeader { message, signature };
+    let response = SignedBuilderBid { message, signature };
 
-    let response = GetHeaderResponse::Electra(response);
+    let response = GetHeaderResponse {
+        version: ForkName::Electra,
+        data: response,
+        metadata: Default::default(),
+    };
     (StatusCode::OK, Json(response)).into_response()
 }
 
@@ -159,16 +169,24 @@ async fn handle_submit_block_v1(
     if state.large_body() {
         (StatusCode::OK, Json(vec![1u8; 1 + MAX_SIZE_SUBMIT_BLOCK_RESPONSE])).into_response()
     } else {
-        let VersionedResponse::Electra(mut response) = SubmitBlindedBlockResponse::default();
-        response.execution_payload.block_hash = submit_block.block_hash();
+        let mut execution_payload = ExecutionPayloadElectra::test_random();
+        execution_payload.block_hash = submit_block.block_hash().into();
+
+        let mut blobs_bundle = BlobsBundle::default();
 
-        let BlindedBeaconBlock::Electra(body) = submit_block.message;
+        blobs_bundle.blobs.push(Default::default()).unwrap();
+        blobs_bundle.commitments =
+            submit_block.as_electra().unwrap().message.body.blob_kzg_commitments.clone();
+        blobs_bundle.proofs.push(KzgProof([0; 48])).unwrap();
 
-        response.blobs_bundle.blobs.push(Default::default()).unwrap();
-        response.blobs_bundle.commitments = body.body.blob_kzg_commitments;
-        response.blobs_bundle.proofs.push(KzgProof([0; 48])).unwrap();
+        let response =
+            PayloadAndBlobs { execution_payload: execution_payload.into(), blobs_bundle };
 
-        let response = VersionedResponse::Electra(response);
+        let response = SubmitBlindedBlockResponse {
+            version: ForkName::Electra,
+            metadata: Default::default(),
+            data: response,
+        };
 
         (StatusCode::OK, Json(response)).into_response()
     }

tests/src/mock_relay.rs

@@ -2,7 +2,10 @@ use std::{sync::Arc, time::Duration};
 
 use alloy::primitives::{B256, U256};
 use cb_common::{
-    pbs::GetHeaderResponse, signature::sign_builder_root, signer::random_secret, types::Chain,
+    pbs::GetHeaderResponse,
+    signature::sign_builder_root,
+    signer::random_secret,
+    types::{BlsPublicKeyBytes, Chain},
     utils::timestamp_of_slot_start_sec,
 };
 use cb_pbs::{DefaultBuilderApi, PbsService, PbsState};
@@ -12,6 +15,7 @@ use cb_tests::{
     utils::{generate_mock_relay, get_pbs_static_config, setup_test_env, to_pbs_config},
 };
 use eyre::Result;
+use lh_types::ForkName;
 use reqwest::StatusCode;
 use tracing::info;
 use tree_hash::TreeHash;
@@ -45,17 +49,17 @@ async fn test_get_header() -> Result<()> {
     assert_eq!(res.status(), StatusCode::OK);
 
     let res = serde_json::from_slice::<GetHeaderResponse>(&res.bytes().await?)?;
-    let GetHeaderResponse::Electra(res) = res;
 
     assert_eq!(mock_state.received_get_header(), 1);
-    assert_eq!(res.message.header.block_hash.0[0], 1);
-    assert_eq!(res.message.header.parent_hash, B256::ZERO);
-    assert_eq!(res.message.value, U256::from(10));
-    assert_eq!(res.message.pubkey, mock_state.signer.public_key());
-    assert_eq!(res.message.header.timestamp, timestamp_of_slot_start_sec(0, chain));
+    assert_eq!(res.version, ForkName::Electra);
+    assert_eq!(res.data.message.header().block_hash().0[0], 1);
+    assert_eq!(res.data.message.header().parent_hash().0, B256::ZERO);
+    assert_eq!(*res.data.message.value(), U256::from(10));
+    assert_eq!(*res.data.message.pubkey(), BlsPublicKeyBytes::from(mock_state.signer.public_key()));
+    assert_eq!(res.data.message.header().timestamp(), timestamp_of_slot_start_sec(0, chain));
     assert_eq!(
-        res.signature,
-        sign_builder_root(chain, &mock_state.signer, res.message.tree_hash_root())
+        res.data.signature,
+        sign_builder_root(chain, &mock_state.signer, res.data.message.tree_hash_root())
     );
     Ok(())
 }

tests/tests/pbs_get_header.rs

@@ -1,7 +1,7 @@
 use std::{sync::Arc, time::Duration};
 
 use cb_common::{
-    pbs::{BuilderApiVersion, SubmitBlindedBlockResponse},
+    pbs::{BuilderApiVersion, GetPyloadInfo, SubmitBlindedBlockResponse},
     signer::random_secret,
     types::Chain,
 };
@@ -23,7 +23,10 @@ async fn test_submit_block_v1() -> Result<()> {
     let signed_blinded_block = load_test_signed_blinded_block();
 
     let response_body = serde_json::from_slice::<SubmitBlindedBlockResponse>(&res.bytes().await?)?;
-    assert_eq!(response_body.block_hash(), signed_blinded_block.block_hash());
+    assert_eq!(
+        response_body.data.execution_payload.block_hash(),
+        signed_blinded_block.block_hash().into()
+    );
     Ok(())
 }