From 1fbe32424c46bbbc0299119a9c3a214bb6a725fb Mon Sep 17 00:00:00 2001 From: PoulavBhowmick03 Date: Sat, 24 May 2025 19:01:09 +0530 Subject: [PATCH 1/5] Removed code for GET validator/blinded_blocks and also adjusted/removed tests for that endpoint --- beacon_node/http_api/src/lib.rs | 34 +- beacon_node/http_api/tests/tests.rs | 684 +++++++++------------------- common/eth2/src/lib.rs | 104 ----- 3 files changed, 223 insertions(+), 599 deletions(-) diff --git a/beacon_node/http_api/src/lib.rs b/beacon_node/http_api/src/lib.rs index 7f6c97a0f85..54a7206f54d 100644 --- a/beacon_node/http_api/src/lib.rs +++ b/beacon_node/http_api/src/lib.rs @@ -33,7 +33,7 @@ mod validator_inclusion; mod validators; mod version; use crate::light_client::{get_light_client_bootstrap, get_light_client_updates}; -use crate::produce_block::{produce_blinded_block_v2, produce_block_v2, produce_block_v3}; +use crate::produce_block::{produce_block_v2, produce_block_v3}; use crate::version::beacon_response; use beacon_chain::{ AttestationError as AttnError, BeaconChain, BeaconChainError, BeaconChainTypes, @@ -256,8 +256,6 @@ pub fn prometheus_metrics() -> warp::filters::log::Log( }, ); - // GET validator/blinded_blocks/{slot} - let get_validator_blinded_blocks = eth_v1 - .and(warp::path("validator")) - .and(warp::path("blinded_blocks")) - .and(warp::path::param::().or_else(|_| async { - Err(warp_utils::reject::custom_bad_request( - "Invalid slot".to_string(), - )) - })) - .and(warp::path::end()) - .and(not_while_syncing_filter.clone()) - .and(warp::query::()) - .and(warp::header::optional::("accept")) - .and(task_spawner_filter.clone()) - .and(chain_filter.clone()) - .then( - |slot: Slot, - not_synced_filter: Result<(), Rejection>, - query: api_types::ValidatorBlocksQuery, - accept_header: Option, - task_spawner: TaskSpawner, - chain: Arc>| { - task_spawner.spawn_async_with_rejection(Priority::P0, async move { - not_synced_filter?; - produce_blinded_block_v2(accept_header, chain, slot, query).await - }) - }, - ); - // GET validator/attestation_data?slot,committee_index let get_validator_attestation_data = eth_v1 .and(warp::path("validator")) @@ -4865,7 +4834,6 @@ pub fn serve( .uor(get_node_peer_count) .uor(get_validator_duties_proposer) .uor(get_validator_blocks) - .uor(get_validator_blinded_blocks) .uor(get_validator_attestation_data) .uor(get_validator_aggregate_attestation) .uor(get_validator_sync_committee_contribution) diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index 9c18a7c1e87..e1a960eddc0 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -3758,229 +3758,6 @@ impl ApiTester { self } - pub async fn test_blinded_block_production(&self) { - let fork = self.chain.canonical_head.cached_head().head_fork(); - let genesis_validators_root = self.chain.genesis_validators_root; - - for _ in 0..E::slots_per_epoch() * 3 { - let slot = self.chain.slot().unwrap(); - let epoch = self.chain.epoch().unwrap(); - - let proposer_pubkey_bytes = self - .client - .get_validator_duties_proposer(epoch) - .await - .unwrap() - .data - .into_iter() - .find(|duty| duty.slot == slot) - .map(|duty| duty.pubkey) - .unwrap(); - let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); - - let sk = self - .validator_keypairs() - .iter() - .find(|kp| kp.pk == proposer_pubkey) - .map(|kp| kp.sk.clone()) - .unwrap(); - - let randao_reveal = { - let domain = self.chain.spec.get_domain( - epoch, - Domain::Randao, - &fork, - genesis_validators_root, - ); - let message = epoch.signing_root(domain); - sk.sign(message).into() - }; - - let block = self - .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) - .await - .unwrap() - .into_data(); - - let signed_block = block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); - - self.client - .post_beacon_blinded_blocks(&signed_block) - .await - .unwrap(); - - let head_block = self - .client - .get_beacon_blocks(CoreBlockId::Head) - .await - .unwrap() - .unwrap() - .into_data(); - - assert_eq!(head_block.clone_as_blinded(), signed_block); - - self.chain.slot_clock.set_slot(slot.as_u64() + 1); - } - } - - pub async fn test_blinded_block_production_ssz(&self) { - let fork = self.chain.canonical_head.cached_head().head_fork(); - let genesis_validators_root = self.chain.genesis_validators_root; - - for _ in 0..E::slots_per_epoch() * 3 { - let slot = self.chain.slot().unwrap(); - let epoch = self.chain.epoch().unwrap(); - - let proposer_pubkey_bytes = self - .client - .get_validator_duties_proposer(epoch) - .await - .unwrap() - .data - .into_iter() - .find(|duty| duty.slot == slot) - .map(|duty| duty.pubkey) - .unwrap(); - let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); - - let sk = self - .validator_keypairs() - .iter() - .find(|kp| kp.pk == proposer_pubkey) - .map(|kp| kp.sk.clone()) - .unwrap(); - - let randao_reveal = { - let domain = self.chain.spec.get_domain( - epoch, - Domain::Randao, - &fork, - genesis_validators_root, - ); - let message = epoch.signing_root(domain); - sk.sign(message).into() - }; - - let block_contents_bytes = self - .client - .get_validator_blinded_blocks_ssz::(slot, &randao_reveal, None) - .await - .unwrap() - .expect("block bytes"); - - let block_contents = - FullBlockContents::::from_ssz_bytes(&block_contents_bytes, &self.chain.spec) - .expect("block contents bytes can be decoded"); - - let signed_block_contents = - block_contents.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); - - self.client - .post_beacon_blinded_blocks_ssz( - &signed_block_contents.signed_block().clone_as_blinded(), - ) - .await - .unwrap(); - - let head_block = self - .client - .get_beacon_blocks(CoreBlockId::Head) - .await - .unwrap() - .unwrap() - .into_data(); - - let signed_block = signed_block_contents.signed_block(); - assert_eq!(head_block, **signed_block); - - self.chain.slot_clock.set_slot(slot.as_u64() + 1); - } - } - - pub async fn test_blinded_block_production_no_verify_randao(self) -> Self { - for _ in 0..E::slots_per_epoch() { - let slot = self.chain.slot().unwrap(); - - let blinded_block = self - .client - .get_validator_blinded_blocks_modular::( - slot, - &Signature::infinity().unwrap().into(), - None, - SkipRandaoVerification::Yes, - ) - .await - .unwrap() - .into_data(); - assert_eq!(blinded_block.slot(), slot); - self.chain.slot_clock.set_slot(slot.as_u64() + 1); - } - - self - } - - pub async fn test_blinded_block_production_verify_randao_invalid(self) -> Self { - let fork = self.chain.canonical_head.cached_head().head_fork(); - let genesis_validators_root = self.chain.genesis_validators_root; - - for _ in 0..E::slots_per_epoch() { - let slot = self.chain.slot().unwrap(); - let epoch = self.chain.epoch().unwrap(); - - let proposer_pubkey_bytes = self - .client - .get_validator_duties_proposer(epoch) - .await - .unwrap() - .data - .into_iter() - .find(|duty| duty.slot == slot) - .map(|duty| duty.pubkey) - .unwrap(); - let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); - - let sk = self - .validator_keypairs() - .iter() - .find(|kp| kp.pk == proposer_pubkey) - .map(|kp| kp.sk.clone()) - .unwrap(); - - let bad_randao_reveal = { - let domain = self.chain.spec.get_domain( - epoch, - Domain::Randao, - &fork, - genesis_validators_root, - ); - let message = (epoch + 1).signing_root(domain); - sk.sign(message).into() - }; - - // Check failure with full randao verification enabled. - self.client - .get_validator_blinded_blocks::(slot, &bad_randao_reveal, None) - .await - .unwrap_err(); - - // Check failure with `skip_randao_verification` (requires infinity sig). - self.client - .get_validator_blinded_blocks_modular::( - slot, - &bad_randao_reveal, - None, - SkipRandaoVerification::Yes, - ) - .await - .unwrap_err(); - - self.chain.slot_clock.set_slot(slot.as_u64() + 1); - } - - self - } - pub async fn test_get_validator_attestation_data(self) -> Self { let mut state = self.chain.head_beacon_state_cloned(); let slot = state.slot(); @@ -4663,16 +4440,19 @@ impl ApiTester { let (proposer_index, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + }; let expected_fee_recipient = Address::from_low_u64_be(proposer_index); assert_eq!(payload.fee_recipient(), expected_fee_recipient); @@ -4710,16 +4490,19 @@ impl ApiTester { let (proposer_index, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), + }; let expected_fee_recipient = Address::from_low_u64_be(proposer_index); assert_eq!(payload.fee_recipient(), expected_fee_recipient); @@ -4755,16 +4538,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // If this cache is populated, it indicates fallback to the local EE was correctly used. assert!( @@ -4830,16 +4616,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + }; assert_eq!(payload.fee_recipient(), test_fee_recipient); @@ -4917,16 +4706,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; assert_eq!(payload.parent_hash(), expected_parent_hash); @@ -4980,7 +4772,7 @@ impl ApiTester { ProduceBlockV3Response::Full(payload) => { payload.block().body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Blinded(_) => panic!("Expecting a blinded payload"), + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), }; assert_eq!(payload.parent_hash(), expected_parent_hash); @@ -5010,16 +4802,19 @@ impl ApiTester { .unwrap(); let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; assert_eq!(payload.prev_randao(), expected_prev_randao); @@ -5101,16 +4896,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; assert_eq!(payload.block_number(), expected_block_number); @@ -5191,16 +4989,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; assert!(payload.timestamp() > min_expected_timestamp); @@ -5251,7 +5052,7 @@ impl ApiTester { ProduceBlockV3Response::Full(payload) => { payload.block().body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Blinded(_) => panic!("Expecting a blinded payload"), + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), }; assert!(payload.timestamp() > min_expected_timestamp); @@ -5267,16 +5068,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // If this cache is populated, it indicates fallback to the local EE was correctly used. assert!( @@ -5331,16 +5135,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // If this cache is populated, it indicates fallback to the local EE was correctly used. assert!( @@ -5408,16 +5215,19 @@ impl ApiTester { .get_test_randao(next_slot, next_slot.epoch(E::slots_per_epoch())) .await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) + .get_validator_blocks_v3::(next_slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + }; // This cache should not be populated because fallback should not have been used. assert!( @@ -5440,16 +5250,19 @@ impl ApiTester { .get_test_randao(next_slot, next_slot.epoch(E::slots_per_epoch())) .await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) + .get_validator_blocks_v3::(next_slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // If this cache is populated, it indicates fallback to the local EE was correctly used. assert!( @@ -5549,16 +5362,19 @@ impl ApiTester { .get_test_randao(next_slot, next_slot.epoch(E::slots_per_epoch())) .await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) + .get_validator_blocks_v3::(next_slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // If this cache is populated, it indicates fallback to the local EE was correctly used. assert!( @@ -5591,16 +5407,19 @@ impl ApiTester { .get_test_randao(next_slot, next_slot.epoch(E::slots_per_epoch())) .await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) + .get_validator_blocks_v3::(next_slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + }; // This cache should not be populated because fallback should not have been used. assert!( @@ -5708,16 +5527,19 @@ impl ApiTester { let (proposer_index, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; let expected_fee_recipient = Address::from_low_u64_be(proposer_index); assert_eq!(payload.fee_recipient(), expected_fee_recipient); @@ -5790,16 +5612,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), + }; // The builder's payload should've been chosen, so this cache should not be populated assert!( @@ -5859,16 +5684,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // The local payload should've been chosen, so this cache should be populated assert!( @@ -5928,16 +5756,19 @@ impl ApiTester { let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // The local payload should've been chosen, so this cache should be populated assert!( @@ -5996,16 +5827,19 @@ impl ApiTester { let epoch = self.chain.epoch().unwrap(); let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: BlindedPayload = match payload_type.data { + ProduceBlockV3Response::Blinded(payload) => { + payload.body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + }; // The builder's payload should've been chosen, so this cache should not be populated assert!( @@ -6068,16 +5902,19 @@ impl ApiTester { let epoch = self.chain.epoch().unwrap(); let (_, randao_reveal) = self.get_test_randao(slot, epoch).await; - let payload: BlindedPayload = self + let (payload_type, metadata) = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) .await - .unwrap() - .into_data() - .body() - .execution_payload() - .unwrap() - .into(); + .unwrap(); + Self::check_block_v3_metadata(&metadata, &payload_type); + + let payload: FullPayload = match payload_type.data { + ProduceBlockV3Response::Full(payload) => { + payload.block().body().execution_payload().unwrap().into() + } + ProduceBlockV3Response::Blinded(_) => panic!("Expecting a full payload"), + }; // The local payload should've been chosen because the builder's was invalid assert!( @@ -7319,83 +7156,6 @@ async fn block_production_v3_ssz_with_skip_slots() { .await; } -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_full_payload_premerge() { - ApiTester::new().await.test_blinded_block_production().await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_ssz_full_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production_ssz() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_with_skip_slots_full_payload_premerge() { - ApiTester::new() - .await - .skip_slots(E::slots_per_epoch() * 2) - .test_blinded_block_production() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_ssz_with_skip_slots_full_payload_premerge() { - ApiTester::new() - .await - .skip_slots(E::slots_per_epoch() * 2) - .test_blinded_block_production_ssz() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_no_verify_randao_full_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production_no_verify_randao() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_verify_randao_invalid_full_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production_verify_randao_invalid() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_blinded_payload_premerge() { - ApiTester::new().await.test_blinded_block_production().await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_with_skip_slots_blinded_payload_premerge() { - ApiTester::new() - .await - .skip_slots(E::slots_per_epoch() * 2) - .test_blinded_block_production() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_no_verify_randao_blinded_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production_no_verify_randao() - .await; -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn blinded_block_production_verify_randao_invalid_blinded_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production_verify_randao_invalid() - .await; -} - #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn get_validator_attestation_data() { ApiTester::new() diff --git a/common/eth2/src/lib.rs b/common/eth2/src/lib.rs index 0423794d0d5..8fdbaf47683 100644 --- a/common/eth2/src/lib.rs +++ b/common/eth2/src/lib.rs @@ -2474,110 +2474,6 @@ impl BeaconNodeHttpClient { .await } - /// `GET v2/validator/blinded_blocks/{slot}` - pub async fn get_validator_blinded_blocks( - &self, - slot: Slot, - randao_reveal: &SignatureBytes, - graffiti: Option<&Graffiti>, - ) -> Result>, Error> { - self.get_validator_blinded_blocks_modular( - slot, - randao_reveal, - graffiti, - SkipRandaoVerification::No, - ) - .await - } - - /// returns `GET v1/validator/blinded_blocks/{slot}` URL path - pub async fn get_validator_blinded_blocks_path( - &self, - slot: Slot, - randao_reveal: &SignatureBytes, - graffiti: Option<&Graffiti>, - skip_randao_verification: SkipRandaoVerification, - ) -> Result { - let mut path = self.eth_path(V1)?; - - path.path_segments_mut() - .map_err(|()| Error::InvalidUrl(self.server.clone()))? - .push("validator") - .push("blinded_blocks") - .push(&slot.to_string()); - - path.query_pairs_mut() - .append_pair("randao_reveal", &randao_reveal.to_string()); - - if let Some(graffiti) = graffiti { - path.query_pairs_mut() - .append_pair("graffiti", &graffiti.to_string()); - } - - if skip_randao_verification == SkipRandaoVerification::Yes { - path.query_pairs_mut() - .append_key_only("skip_randao_verification"); - } - - Ok(path) - } - - /// `GET v1/validator/blinded_blocks/{slot}` - pub async fn get_validator_blinded_blocks_modular( - &self, - slot: Slot, - randao_reveal: &SignatureBytes, - graffiti: Option<&Graffiti>, - skip_randao_verification: SkipRandaoVerification, - ) -> Result>, Error> { - let path = self - .get_validator_blinded_blocks_path::( - slot, - randao_reveal, - graffiti, - skip_randao_verification, - ) - .await?; - - self.get(path).await.map(BeaconResponse::ForkVersioned) - } - - /// `GET v2/validator/blinded_blocks/{slot}` in ssz format - pub async fn get_validator_blinded_blocks_ssz( - &self, - slot: Slot, - randao_reveal: &SignatureBytes, - graffiti: Option<&Graffiti>, - ) -> Result>, Error> { - self.get_validator_blinded_blocks_modular_ssz::( - slot, - randao_reveal, - graffiti, - SkipRandaoVerification::No, - ) - .await - } - - pub async fn get_validator_blinded_blocks_modular_ssz( - &self, - slot: Slot, - randao_reveal: &SignatureBytes, - graffiti: Option<&Graffiti>, - skip_randao_verification: SkipRandaoVerification, - ) -> Result>, Error> { - let path = self - .get_validator_blinded_blocks_path::( - slot, - randao_reveal, - graffiti, - skip_randao_verification, - ) - .await?; - - self.get_bytes_opt_accept_header(path, Accept::Ssz, self.timeouts.get_validator_block) - .await - } - /// `GET validator/attestation_data?slot,committee_index` pub async fn get_validator_attestation_data( &self, From 2fba392e08e17407c1d569bdadcd76ea65950f03 Mon Sep 17 00:00:00 2001 From: PoulavBhowmick03 Date: Thu, 29 May 2025 16:43:47 +0530 Subject: [PATCH 2/5] added back the tests previously removed and modified them to fit in without the blinded block endpoints --- beacon_node/http_api/tests/tests.rs | 347 +++++++++++++++++++++++++++- 1 file changed, 342 insertions(+), 5 deletions(-) diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index e1a960eddc0..ffe094a42b2 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -3758,6 +3758,266 @@ impl ApiTester { self } + pub async fn test_blinded_block_production(&self) { + let fork = self.chain.canonical_head.cached_head().head_fork(); + let genesis_validators_root = self.chain.genesis_validators_root; + + for _ in 0..E::slots_per_epoch() * 3 { + let slot = self.chain.slot().unwrap(); + let epoch = self.chain.epoch().unwrap(); + + let proposer_pubkey_bytes = self + .client + .get_validator_duties_proposer(epoch) + .await + .unwrap() + .data + .into_iter() + .find(|duty| duty.slot == slot) + .map(|duty| duty.pubkey) + .unwrap(); + let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); + + let sk = self + .validator_keypairs() + .iter() + .find(|kp| kp.pk == proposer_pubkey) + .map(|kp| kp.sk.clone()) + .unwrap(); + + let randao_reveal = { + let domain = self.chain.spec.get_domain( + epoch, + Domain::Randao, + &fork, + genesis_validators_root, + ); + let message = epoch.signing_root(domain); + sk.sign(message).into() + }; + + let (response, metadata) = self + .client + .get_validator_blocks_v3::(slot, &randao_reveal, None, None) + .await + .unwrap(); + + match response.data { + ProduceBlockV3Response::Blinded(blinded_block) => { + assert!(metadata.execution_payload_blinded); + assert_eq!( + metadata.consensus_version, + blinded_block.to_ref().fork_name(&self.chain.spec).unwrap() + ); + let signed_blinded_block = + blinded_block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); + + self.client + .post_beacon_blinded_blocks(&signed_blinded_block) + .await + .unwrap(); + + let head_block = self.chain.head_beacon_block().clone_as_blinded(); + assert_eq!(head_block, signed_blinded_block); + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); + } + ProduceBlockV3Response::Full(block_contents) => { + assert!(!metadata.execution_payload_blinded); + assert_eq!( + metadata.consensus_version, + block_contents + .block() + .to_ref() + .fork_name(&self.chain.spec) + .unwrap() + ); + let signed_block_contents = + block_contents.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); + + self.client + .post_beacon_blocks(&signed_block_contents) + .await + .unwrap(); + + assert_eq!( + self.chain.head_beacon_block(), + *signed_block_contents.signed_block() + ); + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); + } + } + } + } + + pub async fn test_blinded_block_production_ssz(&self) { + let fork = self.chain.canonical_head.cached_head().head_fork(); + let genesis_validators_root = self.chain.genesis_validators_root; + + for _ in 0..E::slots_per_epoch() * 3 { + let slot = self.chain.slot().unwrap(); + let epoch = self.chain.epoch().unwrap(); + + let proposer_pubkey_bytes = self + .client + .get_validator_duties_proposer(epoch) + .await + .unwrap() + .data + .into_iter() + .find(|duty| duty.slot == slot) + .map(|duty| duty.pubkey) + .unwrap(); + let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); + + let sk = self + .validator_keypairs() + .iter() + .find(|kp| kp.pk == proposer_pubkey) + .map(|kp| kp.sk.clone()) + .unwrap(); + + let randao_reveal = { + let domain = self.chain.spec.get_domain( + epoch, + Domain::Randao, + &fork, + genesis_validators_root, + ); + let message = epoch.signing_root(domain); + sk.sign(message).into() + }; + + let block_contents_bytes = self + .client + .get_validator_blocks_ssz::(slot, &randao_reveal, None) + .await + .unwrap() + .expect("block bytes"); + + let block_contents = + FullBlockContents::::from_ssz_bytes(&block_contents_bytes, &self.chain.spec) + .expect("block contents bytes can be decoded"); + + let signed_block_contents = + block_contents.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); + + self.client + .post_beacon_blinded_blocks_ssz( + &signed_block_contents.signed_block().clone_as_blinded(), + ) + .await + .unwrap(); + + let head_block = self + .client + .get_beacon_blocks(CoreBlockId::Head) + .await + .unwrap() + .unwrap() + .into_data(); + + let signed_block = signed_block_contents.signed_block(); + assert_eq!(head_block, **signed_block); + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); + } + } + + pub async fn test_blinded_block_production_no_verify_randao(self) -> Self { + for _ in 0..E::slots_per_epoch() { + let slot = self.chain.slot().unwrap(); + + let (response, _metadata) = self + .client + .get_validator_blocks_v3_modular::( + slot, + &Signature::infinity().unwrap().into(), + None, + SkipRandaoVerification::Yes, + None, + ) + .await + .unwrap(); + + match response.data { + ProduceBlockV3Response::Blinded(blinded_block) => { + assert_eq!(blinded_block.slot(), slot); + } + ProduceBlockV3Response::Full(full_block) => { + assert_eq!(full_block.block().slot(), slot); + } + } + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); + } + + self + } + + pub async fn test_blinded_block_production_verify_randao_invalid(self) -> Self { + let fork = self.chain.canonical_head.cached_head().head_fork(); + let genesis_validators_root = self.chain.genesis_validators_root; + + for _ in 0..E::slots_per_epoch() { + let slot = self.chain.slot().unwrap(); + let epoch = self.chain.epoch().unwrap(); + + let proposer_pubkey_bytes = self + .client + .get_validator_duties_proposer(epoch) + .await + .unwrap() + .data + .into_iter() + .find(|duty| duty.slot == slot) + .map(|duty| duty.pubkey) + .unwrap(); + let proposer_pubkey = (&proposer_pubkey_bytes).try_into().unwrap(); + + let sk = self + .validator_keypairs() + .iter() + .find(|kp| kp.pk == proposer_pubkey) + .map(|kp| kp.sk.clone()) + .unwrap(); + + let bad_randao_reveal = { + let domain = self.chain.spec.get_domain( + epoch, + Domain::Randao, + &fork, + genesis_validators_root, + ); + let message = (epoch + 1).signing_root(domain); + sk.sign(message).into() + }; + + // Check failure with full randao verification enabled. + self.client + .get_validator_blocks_v3::(slot, &bad_randao_reveal, None, None) + .await + .unwrap_err(); + + // Check failure with `skip_randao_verification` (requires infinity sig). + self.client + .get_validator_blocks_v3_modular::( + slot, + &bad_randao_reveal, + None, + SkipRandaoVerification::Yes, + None, + ) + .await + .unwrap_err(); + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); + } + + self + } + pub async fn test_get_validator_attestation_data(self) -> Self { let mut state = self.chain.head_beacon_state_cloned(); let slot = state.slot(); @@ -4451,7 +4711,7 @@ impl ApiTester { ProduceBlockV3Response::Blinded(payload) => { payload.body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), }; let expected_fee_recipient = Address::from_low_u64_be(proposer_index); @@ -4627,7 +4887,7 @@ impl ApiTester { ProduceBlockV3Response::Blinded(payload) => { payload.body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), }; assert_eq!(payload.fee_recipient(), test_fee_recipient); @@ -5226,7 +5486,7 @@ impl ApiTester { ProduceBlockV3Response::Blinded(payload) => { payload.body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), }; // This cache should not be populated because fallback should not have been used. @@ -5418,7 +5678,7 @@ impl ApiTester { ProduceBlockV3Response::Blinded(payload) => { payload.body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), }; // This cache should not be populated because fallback should not have been used. @@ -5838,7 +6098,7 @@ impl ApiTester { ProduceBlockV3Response::Blinded(payload) => { payload.body().execution_payload().unwrap().into() } - ProduceBlockV3Response::Full(_) => panic!("Expecting a full payload"), + ProduceBlockV3Response::Full(_) => panic!("Expecting a blinded payload"), }; // The builder's payload should've been chosen, so this cache should not be populated @@ -7156,6 +7416,83 @@ async fn block_production_v3_ssz_with_skip_slots() { .await; } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_full_payload_premerge() { + ApiTester::new().await.test_blinded_block_production().await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_ssz_full_payload_premerge() { + ApiTester::new() + .await + .test_blinded_block_production_ssz() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_with_skip_slots_full_payload_premerge() { + ApiTester::new() + .await + .skip_slots(E::slots_per_epoch() * 2) + .test_blinded_block_production() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_ssz_with_skip_slots_full_payload_premerge() { + ApiTester::new() + .await + .skip_slots(E::slots_per_epoch() * 2) + .test_blinded_block_production_ssz() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_no_verify_randao_full_payload_premerge() { + ApiTester::new() + .await + .test_blinded_block_production_no_verify_randao() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_verify_randao_invalid_full_payload_premerge() { + ApiTester::new() + .await + .test_blinded_block_production_verify_randao_invalid() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_blinded_payload_premerge() { + ApiTester::new().await.test_blinded_block_production().await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_with_skip_slots_blinded_payload_premerge() { + ApiTester::new() + .await + .skip_slots(E::slots_per_epoch() * 2) + .test_blinded_block_production() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_no_verify_randao_blinded_payload_premerge() { + ApiTester::new() + .await + .test_blinded_block_production_no_verify_randao() + .await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn blinded_block_production_verify_randao_invalid_blinded_payload_premerge() { + ApiTester::new() + .await + .test_blinded_block_production_verify_randao_invalid() + .await; +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn get_validator_attestation_data() { ApiTester::new() From 5fed9de0206bbc9231bfe51da8170fdd242278b4 Mon Sep 17 00:00:00 2001 From: PoulavBhowmick03 Date: Fri, 13 Jun 2025 13:17:16 +0530 Subject: [PATCH 3/5] Error in case of Full for test_blinded_block_production --- beacon_node/http_api/tests/tests.rs | 30 ++++------------------------- 1 file changed, 4 insertions(+), 26 deletions(-) diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index ffe094a42b2..2e01d5658f2 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -3822,30 +3822,8 @@ impl ApiTester { self.chain.slot_clock.set_slot(slot.as_u64() + 1); } - ProduceBlockV3Response::Full(block_contents) => { - assert!(!metadata.execution_payload_blinded); - assert_eq!( - metadata.consensus_version, - block_contents - .block() - .to_ref() - .fork_name(&self.chain.spec) - .unwrap() - ); - let signed_block_contents = - block_contents.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); - - self.client - .post_beacon_blocks(&signed_block_contents) - .await - .unwrap(); - - assert_eq!( - self.chain.head_beacon_block(), - *signed_block_contents.signed_block() - ); - - self.chain.slot_clock.set_slot(slot.as_u64() + 1); + ProduceBlockV3Response::Full(_) => { + panic!("Expecting a blinded block"); } } } @@ -3945,8 +3923,8 @@ impl ApiTester { ProduceBlockV3Response::Blinded(blinded_block) => { assert_eq!(blinded_block.slot(), slot); } - ProduceBlockV3Response::Full(full_block) => { - assert_eq!(full_block.block().slot(), slot); + ProduceBlockV3Response::Full(_) => { + panic!("Expecting a blinded block"); } } From f876ade4518bb57b7411c015f6bb08fe4520f33e Mon Sep 17 00:00:00 2001 From: PoulavBhowmick03 Date: Tue, 8 Jul 2025 11:45:53 +0530 Subject: [PATCH 4/5] fixed pre-merge tests --- beacon_node/http_api/tests/tests.rs | 30 +++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index 2e01d5658f2..ffe094a42b2 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -3822,8 +3822,30 @@ impl ApiTester { self.chain.slot_clock.set_slot(slot.as_u64() + 1); } - ProduceBlockV3Response::Full(_) => { - panic!("Expecting a blinded block"); + ProduceBlockV3Response::Full(block_contents) => { + assert!(!metadata.execution_payload_blinded); + assert_eq!( + metadata.consensus_version, + block_contents + .block() + .to_ref() + .fork_name(&self.chain.spec) + .unwrap() + ); + let signed_block_contents = + block_contents.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); + + self.client + .post_beacon_blocks(&signed_block_contents) + .await + .unwrap(); + + assert_eq!( + self.chain.head_beacon_block(), + *signed_block_contents.signed_block() + ); + + self.chain.slot_clock.set_slot(slot.as_u64() + 1); } } } @@ -3923,8 +3945,8 @@ impl ApiTester { ProduceBlockV3Response::Blinded(blinded_block) => { assert_eq!(blinded_block.slot(), slot); } - ProduceBlockV3Response::Full(_) => { - panic!("Expecting a blinded block"); + ProduceBlockV3Response::Full(full_block) => { + assert_eq!(full_block.block().slot(), slot); } } From 25ea22b7f5827f506310f16c27d2d340a98a3f12 Mon Sep 17 00:00:00 2001 From: PoulavBhowmick03 Date: Thu, 9 Oct 2025 23:19:42 +0530 Subject: [PATCH 5/5] updated to the changes, tested locally --- beacon_node/http_api/src/produce_block.rs | 29 ----------------------- 1 file changed, 29 deletions(-) diff --git a/beacon_node/http_api/src/produce_block.rs b/beacon_node/http_api/src/produce_block.rs index 367e09969b4..dc008641790 100644 --- a/beacon_node/http_api/src/produce_block.rs +++ b/beacon_node/http_api/src/produce_block.rs @@ -133,35 +133,6 @@ pub fn build_response_v3( } } -pub async fn produce_blinded_block_v2( - accept_header: Option, - chain: Arc>, - slot: Slot, - query: api_types::ValidatorBlocksQuery, -) -> Result, warp::Rejection> { - let randao_reveal = query.randao_reveal.decompress().map_err(|e| { - warp_utils::reject::custom_bad_request(format!( - "randao reveal is not a valid BLS signature: {:?}", - e - )) - })?; - - let randao_verification = get_randao_verification(&query, randao_reveal.is_infinity())?; - let block_response_type = chain - .produce_block_with_verification( - randao_reveal, - slot, - query.graffiti, - randao_verification, - None, - BlockProductionVersion::BlindedV2, - ) - .await - .map_err(warp_utils::reject::unhandled_error)?; - - build_response_v2(chain, block_response_type, accept_header) -} - #[instrument( name = SPAN_PRODUCE_BLOCK_V2, skip_all,