From fb5facb23e74f1ed93a3f17bf83f007013627a0e Mon Sep 17 00:00:00 2001 From: realbigsean Date: Tue, 7 Nov 2023 17:51:44 -0500 Subject: [PATCH 1/9] get compiling --- beacon_node/beacon_chain/src/beacon_chain.rs | 64 +- .../beacon_chain/src/block_verification.rs | 24 +- beacon_node/beacon_chain/src/test_utils.rs | 51 +- beacon_node/builder_client/src/lib.rs | 4 +- beacon_node/execution_layer/src/lib.rs | 44 +- .../src/test_utils/mock_builder.rs | 8 +- .../http_api/src/build_block_contents.rs | 67 +- beacon_node/http_api/src/lib.rs | 43 +- beacon_node/http_api/src/produce_block.rs | 66 +- beacon_node/http_api/src/publish_blocks.rs | 32 +- .../tests/broadcast_validation_tests.rs | 26 +- common/eth2/src/lib.rs | 90 ++- common/eth2/src/types.rs | 597 ++++++++---------- consensus/types/src/blob_sidecar.rs | 90 --- consensus/types/src/builder_bid.rs | 13 +- consensus/types/src/lib.rs | 7 +- consensus/types/src/payload.rs | 24 - consensus/types/src/sidecar.rs | 191 ------ validator_client/src/block_service.rs | 165 +++-- 19 files changed, 576 insertions(+), 1030 deletions(-) delete mode 100644 consensus/types/src/sidecar.rs diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index 45f2bbd8df2..782943aa41b 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -122,7 +122,6 @@ use tree_hash::TreeHash; use types::beacon_state::CloneConfig; use types::blob_sidecar::{BlobSidecarList, FixedBlobSidecarList}; use types::payload::BlockProductionVersion; -use types::sidecar::BlobItems; use types::*; pub type ForkChoiceError = fork_choice::Error; @@ -490,10 +489,37 @@ pub enum BeaconBlockResponseType { Blinded(BeaconBlockResponse>), } +impl BeaconBlockResponseType { + pub fn fork_name(&self, spec: &ChainSpec) -> Result { + Ok(match self { + BeaconBlockResponseType::Full(resp) => resp.block.to_ref().fork_name(&spec)?, + BeaconBlockResponseType::Blinded(resp) => resp.block.to_ref().fork_name(&spec)?, + }) + } + + pub fn execution_payload_value(&self) -> Option { + match self { + BeaconBlockResponseType::Full(resp) => resp.execution_payload_value.clone(), + BeaconBlockResponseType::Blinded(resp) => resp.execution_payload_value.clone(), + } + } + + pub fn consensus_block_value(&self) -> Option { + match self { + BeaconBlockResponseType::Full(resp) => resp.consensus_block_value.clone(), + BeaconBlockResponseType::Blinded(resp) => resp.consensus_block_value.clone(), + } + } + + pub fn is_blinded(&self) -> bool { + matches!(self, BeaconBlockResponseType::Blinded(_)) + } +} + pub struct BeaconBlockResponse> { pub block: BeaconBlock, pub state: BeaconState, - pub blob_items: Option<(KzgProofs, >::BlobItems)>, + pub blob_items: Option<(KzgProofs, BlobsList)>, pub execution_payload_value: Option, pub consensus_block_value: Option, } @@ -5148,7 +5174,7 @@ impl BeaconChain { let blobs_verification_timer = metrics::start_timer(&metrics::BLOCK_PRODUCTION_BLOBS_VERIFICATION_TIMES); let blob_item = match (blobs_opt, proofs_opt) { - (Some(blobs_or_blobs_roots), Some(proofs)) => { + (Some(blobs), Some(proofs)) => { let expected_kzg_commitments = block.body().blob_kzg_commitments().map_err(|_| { BlockProductionError::InvalidBlockVariant( @@ -5156,32 +5182,34 @@ impl BeaconChain { ) })?; - if expected_kzg_commitments.len() != blobs_or_blobs_roots.len() { + if expected_kzg_commitments.len() != blobs.len() { return Err(BlockProductionError::MissingKzgCommitment(format!( "Missing KZG commitment for slot {}. Expected {}, got: {}", block.slot(), - blobs_or_blobs_roots.len(), + blobs.len(), expected_kzg_commitments.len() ))); } let kzg_proofs = Vec::from(proofs); - if let Some(blobs) = blobs_or_blobs_roots.blobs() { - let kzg = self - .kzg - .as_ref() - .ok_or(BlockProductionError::TrustedSetupNotInitialized)?; - kzg_utils::validate_blobs::( - kzg, - expected_kzg_commitments, - blobs.iter().collect(), - &kzg_proofs, - ) - .map_err(BlockProductionError::KzgError)?; + let kzg = self + .kzg + .as_ref() + .ok_or(BlockProductionError::TrustedSetupNotInitialized)?; + if !kzg_utils::validate_blobs::( + kzg, + expected_kzg_commitments, + blobs.iter().collect(), + &kzg_proofs, + ) + .map_err(BlockProductionError::KzgError)? + { + //TODO(sean) fix + return Err(BlockProductionError::KzgError(todo!())); } - Some((kzg_proofs.into(), blobs_or_blobs_roots)) + Some((kzg_proofs.into(), blobs)) } _ => None, }; diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs index 4f9b9beb76e..c565db5d9c4 100644 --- a/beacon_node/beacon_chain/src/block_verification.rs +++ b/beacon_node/beacon_chain/src/block_verification.rs @@ -103,7 +103,7 @@ use types::{ EthSpec, ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch, SignedBeaconBlock, SignedBeaconBlockHeader, Slot, }; -use types::{BlobSidecar, ExecPayload, Sidecar}; +use types::{BlobSidecar, ExecPayload}; pub const POS_PANDA_BANNER: &str = r#" ,,, ,,, ,,, ,,, @@ -708,19 +708,15 @@ impl IntoGossipVerifiedBlockContents for SignedBlockCont })?; let gossip_verified_blobs = blob_items .map(|(kzg_proofs, blobs)| { - let sidecars = BlobSidecar::build_sidecar( - blobs, - &block, - expected_kzg_commitments, - kzg_proofs.into(), - ) - .map_err(BlockContentsError::SidecarError)?; - Ok::<_, BlockContentsError>(VariableList::from( - sidecars - .into_iter() - .map(|blob| GossipVerifiedBlob::new(blob, chain)) - .collect::, _>>()?, - )) + let gossip_verified_blobs = kzg_proofs + .into_iter() + .zip(blobs.into_iter()) + .map(|(proof, blob)| { + //TODO(sean) construct blob sidecar + GossipVerifiedBlob::new(Arc::new(BlobSidecar::empty()), chain) + }) + .collect::, GossipBlobError>>()?; + Ok::<_, GossipBlobError>(VariableList::from(gossip_verified_blobs)) }) .transpose()?; let gossip_verified_block = GossipVerifiedBlock::new(Arc::new(block), chain)?; diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs index 645c003497f..43169055eff 100644 --- a/beacon_node/beacon_chain/src/test_utils.rs +++ b/beacon_node/beacon_chain/src/test_utils.rs @@ -811,24 +811,9 @@ where &self, state: BeaconState, slot: Slot, - ) -> ( - SignedBlockContentsTuple>, - BeaconState, - ) { + ) -> (SignedBlindedBeaconBlock, BeaconState) { let (unblinded, new_state) = self.make_block(state, slot).await; - let blob_items = unblinded.1.map(|(kzg_proofs, unblinded_blobs)| { - ( - kzg_proofs, - VariableList::new( - unblinded_blobs - .into_iter() - .map(|blob| blob.tree_hash_root()) - .collect(), - ) - .unwrap(), - ) - }); - ((unblinded.0.into(), blob_items), new_state) + (unblinded.0.into(), new_state) } /// Returns a newly created block, signed by the proposer for the given slot. @@ -836,7 +821,7 @@ where &self, mut state: BeaconState, slot: Slot, - ) -> (SignedBlockContentsTuple>, BeaconState) { + ) -> (SignedBlockContentsTuple, BeaconState) { assert_ne!(slot, 0, "can't produce a block at slot 0"); assert!(slot >= state.slot()); @@ -878,7 +863,7 @@ where &self.spec, ); - let block_contents: SignedBlockContentsTuple> = match &signed_block { + let block_contents: SignedBlockContentsTuple = match &signed_block { SignedBeaconBlock::Base(_) | SignedBeaconBlock::Altair(_) | SignedBeaconBlock::Merge(_) @@ -895,7 +880,7 @@ where &self, mut state: BeaconState, slot: Slot, - ) -> (SignedBlockContentsTuple>, BeaconState) { + ) -> (SignedBlockContentsTuple, BeaconState) { assert_ne!(slot, 0, "can't produce a block at slot 0"); assert!(slot >= state.slot()); @@ -939,7 +924,7 @@ where &self.spec, ); - let block_contents: SignedBlockContentsTuple> = match &signed_block { + let block_contents: SignedBlockContentsTuple = match &signed_block { SignedBeaconBlock::Base(_) | SignedBeaconBlock::Altair(_) | SignedBeaconBlock::Merge(_) @@ -1740,7 +1725,7 @@ where state: BeaconState, slot: Slot, block_modifier: impl FnOnce(&mut BeaconBlock), - ) -> (SignedBlockContentsTuple>, BeaconState) { + ) -> (SignedBlockContentsTuple, BeaconState) { assert_ne!(slot, 0, "can't produce a block at slot 0"); assert!(slot >= state.slot()); @@ -1838,20 +1823,14 @@ where &self, slot: Slot, block_root: Hash256, - block_contents: SignedBlockContentsTuple>, + block_contents: SignedBlockContentsTuple, ) -> Result> { self.set_current_slot(slot); let (block, blobs) = block_contents; let sidecars = if let Some(blob_items) = blobs { let expected_kzg_commitments = block.message().body().blob_kzg_commitments().unwrap(); - Sidecar::build_sidecar( - blob_items.1, - &block, - expected_kzg_commitments, - blob_items.0.into(), - ) - .ok() + todo!() } else { None }; @@ -1872,19 +1851,13 @@ where pub async fn process_block_result( &self, - block_contents: SignedBlockContentsTuple>, + block_contents: SignedBlockContentsTuple, ) -> Result> { let (block, blobs) = block_contents; let sidecars = if let Some(blob_items) = blobs { let expected_kzg_commitments = block.message().body().blob_kzg_commitments().unwrap(); - Sidecar::build_sidecar( - blob_items.1, - &block, - expected_kzg_commitments, - blob_items.0.into(), - ) - .ok() + todo!() } else { None }; @@ -1962,7 +1935,7 @@ where ) -> Result< ( SignedBeaconBlockHash, - SignedBlockContentsTuple>, + SignedBlockContentsTuple, BeaconState, ), BlockError, diff --git a/beacon_node/builder_client/src/lib.rs b/beacon_node/builder_client/src/lib.rs index 28cd1fe4869..22e909041fc 100644 --- a/beacon_node/builder_client/src/lib.rs +++ b/beacon_node/builder_client/src/lib.rs @@ -1,9 +1,9 @@ use eth2::types::builder_bid::SignedBuilderBid; -use eth2::types::FullPayloadContents; use eth2::types::{ BlindedPayload, EthSpec, ExecutionBlockHash, ForkVersionedResponse, PublicKeyBytes, SignedBlockContents, SignedValidatorRegistrationData, Slot, }; +use eth2::types::{FullPayloadContents, SignedBlindedBeaconBlock}; pub use eth2::Error; use eth2::{ok_or_error, StatusCode}; use reqwest::{IntoUrl, Response}; @@ -140,7 +140,7 @@ impl BuilderHttpClient { /// `POST /eth/v1/builder/blinded_blocks` pub async fn post_builder_blinded_blocks( &self, - blinded_block: &SignedBlockContents>, + blinded_block: &SignedBlindedBeaconBlock, ) -> Result>, Error> { let mut path = self.server.full.clone(); diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs index 3f75d0042de..7c076af0db9 100644 --- a/beacon_node/execution_layer/src/lib.rs +++ b/beacon_node/execution_layer/src/lib.rs @@ -14,8 +14,8 @@ pub use engine_api::*; pub use engine_api::{http, http::deposit_methods, http::HttpJsonRpc}; use engines::{Engine, EngineError}; pub use engines::{EngineState, ForkchoiceState}; +use eth2::types::FullPayloadContents; use eth2::types::{builder_bid::SignedBuilderBid, BlobsBundle, ForkVersionedResponse}; -use eth2::types::{FullPayloadContents, SignedBlockContents}; use ethers_core::types::Transaction as EthersTransaction; use fork_choice::ForkchoiceUpdateParameters; use lru::LruCache; @@ -43,8 +43,9 @@ use tree_hash::TreeHash; use types::beacon_block_body::KzgCommitments; use types::builder_bid::BuilderBid; use types::payload::BlockProductionVersion; -use types::sidecar::{BlobItems, Sidecar}; -use types::{AbstractExecPayload, ExecutionPayloadDeneb, KzgProofs}; +use types::{ + AbstractExecPayload, BlobsList, ExecutionPayloadDeneb, KzgProofs, SignedBlindedBeaconBlock, +}; use types::{ BeaconStateError, BlindedPayload, ChainSpec, Epoch, ExecPayload, ExecutionPayloadCapella, ExecutionPayloadMerge, FullPayload, ProposerPreparationData, PublicKeyBytes, Signature, Slot, @@ -109,12 +110,9 @@ impl TryFrom> for ProvenancedPayload::try_from_blob_roots( - builder_bid.blinded_blobs_bundle.blob_roots, - ) - .map_err(Error::InvalidBlobConversion)?, - proofs: builder_bid.blinded_blobs_bundle.proofs, + kzg_commitments: builder_bid.blob_kzg_commitments, + blobs: None, + proofs: None, }, }; Ok(ProvenancedPayload::Builder( @@ -176,8 +174,8 @@ pub enum BlockProposalContents> { payload: Payload, block_value: Uint256, kzg_commitments: KzgCommitments, - blobs: >::BlobItems, - proofs: KzgProofs, + blobs: Option>, + proofs: Option>, }, } @@ -209,9 +207,8 @@ impl> TryFrom> payload: execution_payload.into(), block_value, kzg_commitments: bundle.commitments, - blobs: BlobItems::try_from_blobs(bundle.blobs) - .map_err(Error::InvalidBlobConversion)?, - proofs: bundle.proofs, + blobs: Some(bundle.blobs), + proofs: Some(bundle.proofs), }), None => Ok(Self::Payload { payload: execution_payload.into(), @@ -239,7 +236,7 @@ impl> BlockProposalContents ( Payload, Option>, - Option<>::BlobItems>, + Option>, Option>, Uint256, ) { @@ -254,13 +251,7 @@ impl> BlockProposalContents ( - payload, - Some(kzg_commitments), - Some(blobs), - Some(proofs), - block_value, - ), + } => (payload, Some(kzg_commitments), blobs, proofs, block_value), } } @@ -293,9 +284,11 @@ impl> BlockProposalContents BlockProposalContents::PayloadAndBlobs { payload: Payload::default_at_fork(fork_name)?, block_value: Uint256::zero(), - blobs: Payload::default_blobs_at_fork(fork_name)?, kzg_commitments: VariableList::default(), - proofs: VariableList::default(), + //TODO(sean) fix + // blobs: Some(Payload::default_blobs_at_fork(fork_name)?), + blobs: None, + proofs: Some(VariableList::default()), }, }) } @@ -1965,7 +1958,7 @@ impl ExecutionLayer { pub async fn propose_blinded_beacon_block( &self, block_root: Hash256, - block: &SignedBlockContents>, + block: &SignedBlindedBeaconBlock, ) -> Result, Error> { debug!( self.log(), @@ -2014,7 +2007,6 @@ impl ExecutionLayer { "relay_response_ms" => duration.as_millis(), "block_root" => ?block_root, "parent_hash" => ?block - .signed_block() .message() .execution_payload() .map(|payload| format!("{}", payload.parent_hash())) diff --git a/beacon_node/execution_layer/src/test_utils/mock_builder.rs b/beacon_node/execution_layer/src/test_utils/mock_builder.rs index 32b352b6aee..7da2022d588 100644 --- a/beacon_node/execution_layer/src/test_utils/mock_builder.rs +++ b/beacon_node/execution_layer/src/test_utils/mock_builder.rs @@ -533,8 +533,8 @@ pub fn serve( .as_deneb() .map_err(|_| reject("incorrect payload variant"))? .into(), - blinded_blobs_bundle: maybe_blobs_bundle - .map(Into::into) + blob_kzg_commitments: maybe_blobs_bundle + .map(|b| b.commitments) .unwrap_or_default(), value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI), pubkey: builder.builder_sk.public_key().compress(), @@ -572,8 +572,8 @@ pub fn serve( .as_deneb() .map_err(|_| reject("incorrect payload variant"))? .into(), - blinded_blobs_bundle: maybe_blobs_bundle - .map(Into::into) + blob_kzg_commitments: maybe_blobs_bundle + .map(|b| b.commitments) .unwrap_or_default(), value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI), pubkey: builder.builder_sk.public_key().compress(), diff --git a/beacon_node/http_api/src/build_block_contents.rs b/beacon_node/http_api/src/build_block_contents.rs index 1120f7e1237..29bafc5ff1b 100644 --- a/beacon_node/http_api/src/build_block_contents.rs +++ b/beacon_node/http_api/src/build_block_contents.rs @@ -1,48 +1,41 @@ -use beacon_chain::BlockProductionError; -use eth2::types::{BeaconBlockAndBlobSidecars, BlockContents}; -use types::{AbstractExecPayload, BeaconBlock, EthSpec, ForkName, KzgProofs, Sidecar}; +use beacon_chain::{BeaconBlockResponse, BeaconBlockResponseType, BlockProductionError}; +use eth2::types::{BeaconBlockAndBlobSidecars, BlockContents, BlockContentsWrapper}; +use serde::{Deserialize, Serialize}; +use types::{BlindedBeaconBlock, EthSpec, ForkName}; type Error = warp::reject::Rejection; -pub fn build_block_contents>( +pub fn build_block_contents( fork_name: ForkName, - block: BeaconBlock, - blob_item: Option<(KzgProofs, >::BlobItems)>, -) -> Result, Error> { - match Payload::block_type() { - types::BlockType::Blinded => match fork_name { - ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { - Ok(BlockContents::Block(block)) - } + block_response: BeaconBlockResponseType, +) -> Result, Error> { + match block_response { + BeaconBlockResponseType::Blinded(block) => Ok(BlockContentsWrapper::Blinded(block.block)), + BeaconBlockResponseType::Full(block) => match fork_name { + ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => Ok( + BlockContentsWrapper::Full(BlockContents::Block(block.block)), + ), ForkName::Deneb => { - if blob_item.is_some() { - // We return same blinded block as pre-deneb here, but - // make sure to return an error if the blob items are `None`. - Ok(BlockContents::Block(block)) - } else { - Err(warp_utils::reject::block_production_error( + let BeaconBlockResponse { + block, + state: _, + blob_items, + execution_payload_value: _, + consensus_block_value: _, + } = block; + + let Some((kzg_proofs, blobs)) = blob_items else { + return Err(warp_utils::reject::block_production_error( BlockProductionError::MissingBlobs, - )) - } - } - }, - types::BlockType::Full => match fork_name { - ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { - Ok(BlockContents::Block(block)) - } - ForkName::Deneb => { - if let Some((kzg_proofs, blobs)) = blob_item { - let block_and_blobs = BeaconBlockAndBlobSidecars { + )); + }; + + Ok(BlockContentsWrapper::Full( + BlockContents::BlockAndBlobSidecars(BeaconBlockAndBlobSidecars { block, kzg_proofs, blobs, - }; - - Ok(BlockContents::BlockAndBlobSidecars(block_and_blobs)) - } else { - Err(warp_utils::reject::block_production_error( - BlockProductionError::MissingBlobs, - )) - } + }), + )) } }, } diff --git a/beacon_node/http_api/src/lib.rs b/beacon_node/http_api/src/lib.rs index 309db204ae2..83a029828e4 100644 --- a/beacon_node/http_api/src/lib.rs +++ b/beacon_node/http_api/src/lib.rs @@ -41,7 +41,7 @@ use bytes::Bytes; use directory::DEFAULT_ROOT_DIR; use eth2::types::{ self as api_types, BroadcastValidation, EndpointVersion, ForkChoice, ForkChoiceNode, - SignedBlindedBlockContents, SignedBlockContents, ValidatorId, ValidatorStatus, + SignedBlockContents, ValidatorId, ValidatorStatus, }; use lighthouse_network::{types::SyncState, EnrExt, NetworkGlobals, PeerId, PubsubMessage}; use lighthouse_version::version_with_platform; @@ -78,8 +78,9 @@ use types::{ Attestation, AttestationData, AttestationShufflingId, AttesterSlashing, BeaconStateError, BlindedPayload, CommitteeCache, ConfigAndPreset, Epoch, EthSpec, ForkName, ProposerPreparationData, ProposerSlashing, RelativeEpoch, SignedAggregateAndProof, - SignedBlsToExecutionChange, SignedContributionAndProof, SignedValidatorRegistrationData, - SignedVoluntaryExit, Slot, SyncCommitteeMessage, SyncContributionData, + SignedBlindedBeaconBlock, SignedBlsToExecutionChange, SignedContributionAndProof, + SignedValidatorRegistrationData, SignedVoluntaryExit, Slot, SyncCommitteeMessage, + SyncContributionData, }; use validator::pubkey_to_validator_index; use version::{ @@ -1434,7 +1435,7 @@ pub fn serve( .and(network_tx_filter.clone()) .and(log_filter.clone()) .then( - move |block_contents: SignedBlindedBlockContents, + move |block_contents: SignedBlindedBeaconBlock, task_spawner: TaskSpawner, chain: Arc>, network_tx: UnboundedSender>, @@ -1470,14 +1471,13 @@ pub fn serve( network_tx: UnboundedSender>, log: Logger| { task_spawner.spawn_async_with_rejection(Priority::P0, async move { - let block = - SignedBlockContents::>::from_ssz_bytes( - &block_bytes, - &chain.spec, - ) - .map_err(|e| { - warp_utils::reject::custom_bad_request(format!("invalid SSZ: {e:?}")) - })?; + let block = SignedBlindedBeaconBlock::::from_ssz_bytes( + &block_bytes, + &chain.spec, + ) + .map_err(|e| { + warp_utils::reject::custom_bad_request(format!("invalid SSZ: {e:?}")) + })?; publish_blocks::publish_blinded_block( block, chain, @@ -1503,14 +1503,14 @@ pub fn serve( .and(log_filter.clone()) .then( move |validation_level: api_types::BroadcastValidationQuery, - block_contents: SignedBlindedBlockContents, + blinded_block: SignedBlindedBeaconBlock, task_spawner: TaskSpawner, chain: Arc>, network_tx: UnboundedSender>, log: Logger| { task_spawner.spawn_async_with_rejection(Priority::P0, async move { publish_blocks::publish_blinded_block( - block_contents, + blinded_block, chain, &network_tx, log, @@ -1540,14 +1540,13 @@ pub fn serve( network_tx: UnboundedSender>, log: Logger| { task_spawner.spawn_async_with_rejection(Priority::P0, async move { - let block = - SignedBlockContents::>::from_ssz_bytes( - &block_bytes, - &chain.spec, - ) - .map_err(|e| { - warp_utils::reject::custom_bad_request(format!("invalid SSZ: {e:?}")) - })?; + let block = SignedBlindedBeaconBlock::::from_ssz_bytes( + &block_bytes, + &chain.spec, + ) + .map_err(|e| { + warp_utils::reject::custom_bad_request(format!("invalid SSZ: {e:?}")) + })?; publish_blocks::publish_blinded_block( block, chain, diff --git a/beacon_node/http_api/src/produce_block.rs b/beacon_node/http_api/src/produce_block.rs index f39fef07a67..af94d3e9915 100644 --- a/beacon_node/http_api/src/produce_block.rs +++ b/beacon_node/http_api/src/produce_block.rs @@ -69,35 +69,23 @@ pub async fn produce_block_v3( warp_utils::reject::custom_bad_request(format!("failed to fetch a block: {:?}", e)) })?; - match block_response_type { - BeaconBlockResponseType::Full(block_response) => { - build_response_v3(chain, block_response, endpoint_version, accept_header) - } - BeaconBlockResponseType::Blinded(block_response) => { - build_response_v3(chain, block_response, endpoint_version, accept_header) - } - } + build_response_v3(chain, block_response_type, endpoint_version, accept_header) } -pub fn build_response_v3>( +pub fn build_response_v3( chain: Arc>, - block_response: BeaconBlockResponse, + block_response: BeaconBlockResponseType, endpoint_version: EndpointVersion, accept_header: Option, ) -> Result, warp::Rejection> { let fork_name = block_response - .block - .to_ref() .fork_name(&chain.spec) .map_err(inconsistent_fork_rejection)?; + let execution_payload_value = block_response.execution_payload_value(); + let consensus_block_value = block_response.consensus_block_value(); + let execution_payload_blinded = block_response.is_blinded(); - let block_contents = build_block_contents::build_block_contents( - fork_name, - block_response.block, - block_response.blob_items, - )?; - - let execution_payload_blinded = Payload::block_type() == BlockType::Blinded; + let block_contents = build_block_contents::build_block_contents(fork_name, block_response)?; match accept_header { Some(api_types::Accept::Ssz) => Response::builder() @@ -107,9 +95,9 @@ pub fn build_response_v3| add_consensus_version_header(res, fork_name)) .map(|res| add_execution_payload_blinded_header(res, execution_payload_blinded)) .map(|res: Response| { - add_execution_payload_value_header(res, block_response.execution_payload_value) + add_execution_payload_value_header(res, execution_payload_value) }) - .map(|res| add_consensus_block_value_header(res, block_response.consensus_block_value)) + .map(|res| add_consensus_block_value_header(res, consensus_block_value)) .map_err(|e| -> warp::Rejection { warp_utils::reject::custom_server_error(format!("failed to create response: {}", e)) }), @@ -117,10 +105,8 @@ pub fn build_response_v3( .await .map_err(warp_utils::reject::block_production_error)?; - match block_response_type { - BeaconBlockResponseType::Full(block_response) => { - build_response_v2(chain, block_response, endpoint_version, accept_header) - } - BeaconBlockResponseType::Blinded(block_response) => { - build_response_v2(chain, block_response, endpoint_version, accept_header) - } - } + build_response_v2(chain, block_response_type, endpoint_version, accept_header) } pub async fn produce_block_v2( @@ -187,33 +166,20 @@ pub async fn produce_block_v2( .await .map_err(warp_utils::reject::block_production_error)?; - match block_response_type { - BeaconBlockResponseType::Full(block_response) => { - build_response_v2(chain, block_response, endpoint_version, accept_header) - } - BeaconBlockResponseType::Blinded(block_response) => { - build_response_v2(chain, block_response, endpoint_version, accept_header) - } - } + build_response_v2(chain, block_response_type, endpoint_version, accept_header) } -pub fn build_response_v2>( +pub fn build_response_v2( chain: Arc>, - block_response: BeaconBlockResponse, + block_response: BeaconBlockResponseType, endpoint_version: EndpointVersion, accept_header: Option, ) -> Result, warp::Rejection> { let fork_name = block_response - .block - .to_ref() .fork_name(&chain.spec) .map_err(inconsistent_fork_rejection)?; - let block_contents = build_block_contents::build_block_contents( - fork_name, - block_response.block, - block_response.blob_items, - )?; + let block_contents = build_block_contents::build_block_contents(fork_name, block_response)?; match accept_header { Some(api_types::Accept::Ssz) => Response::builder() diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs index 6c2ccf596d3..3db3a3b6104 100644 --- a/beacon_node/http_api/src/publish_blocks.rs +++ b/beacon_node/http_api/src/publish_blocks.rs @@ -6,7 +6,7 @@ use beacon_chain::{ AvailabilityProcessingStatus, BeaconChain, BeaconChainError, BeaconChainTypes, BlockError, IntoGossipVerifiedBlockContents, NotifyExecutionLayer, }; -use eth2::types::{BroadcastValidation, ErrorMessage}; +use eth2::types::{into_full_block_and_blobs, BroadcastValidation, ErrorMessage}; use eth2::types::{FullPayloadContents, SignedBlockContents}; use execution_layer::ProvenancedPayload; use lighthouse_network::PubsubMessage; @@ -21,6 +21,7 @@ use tree_hash::TreeHash; use types::{ AbstractExecPayload, BeaconBlockRef, BlindedPayload, BlobSidecarList, EthSpec, ExecPayload, ExecutionBlockHash, ForkName, FullPayload, FullPayloadMerge, Hash256, SignedBeaconBlock, + SignedBlindedBeaconBlock, }; use warp::http::StatusCode; use warp::{reply::Response, Rejection, Reply}; @@ -292,16 +293,16 @@ pub async fn publish_block( - block_contents: SignedBlockContents>, + blinded_block: SignedBlindedBeaconBlock, chain: Arc>, network_tx: &UnboundedSender>, log: Logger, validation_level: BroadcastValidation, duplicate_status_code: StatusCode, ) -> Result { - let block_root = block_contents.signed_block().canonical_root(); + let block_root = blinded_block.canonical_root(); let full_block: ProvenancedBlock> = - reconstruct_block(chain.clone(), block_root, block_contents, log.clone()).await?; + reconstruct_block(chain.clone(), block_root, blinded_block, log.clone()).await?; publish_block::( Some(block_root), full_block, @@ -320,10 +321,9 @@ pub async fn publish_blinded_block( pub async fn reconstruct_block( chain: Arc>, block_root: Hash256, - block_contents: SignedBlockContents>, + block: SignedBlindedBeaconBlock, log: Logger, ) -> Result>, Rejection> { - let block = block_contents.signed_block(); let full_payload_opt = if let Ok(payload_header) = block.message().body().execution_payload() { let el = chain.execution_layer.as_ref().ok_or_else(|| { warp_utils::reject::custom_server_error("Missing execution layer".to_string()) @@ -365,7 +365,7 @@ pub async fn reconstruct_block( ); let full_payload = el - .propose_blinded_beacon_block(block_root, &block_contents) + .propose_blinded_beacon_block(block_root, &block) .await .map_err(|e| { warp_utils::reject::custom_server_error(format!( @@ -385,15 +385,15 @@ pub async fn reconstruct_block( match full_payload_opt { // A block without a payload is pre-merge and we consider it locally // built. - None => block_contents - .try_into_full_block_and_blobs(None) - .map(ProvenancedBlock::local), - Some(ProvenancedPayload::Local(full_payload_contents)) => block_contents - .try_into_full_block_and_blobs(Some(full_payload_contents)) - .map(ProvenancedBlock::local), - Some(ProvenancedPayload::Builder(full_payload_contents)) => block_contents - .try_into_full_block_and_blobs(Some(full_payload_contents)) - .map(ProvenancedBlock::builder), + None => into_full_block_and_blobs(block, None).map(ProvenancedBlock::local), + Some(ProvenancedPayload::Local(full_payload_contents)) => { + into_full_block_and_blobs(block, Some(full_payload_contents)) + .map(ProvenancedBlock::local) + } + Some(ProvenancedPayload::Builder(full_payload_contents)) => { + into_full_block_and_blobs(block, Some(full_payload_contents)) + .map(ProvenancedBlock::builder) + } } .map_err(|e| { warp_utils::reject::custom_server_error(format!("Unable to add payload to block: {e:?}")) diff --git a/beacon_node/http_api/tests/broadcast_validation_tests.rs b/beacon_node/http_api/tests/broadcast_validation_tests.rs index fe300ae5e1d..09e00f44a42 100644 --- a/beacon_node/http_api/tests/broadcast_validation_tests.rs +++ b/beacon_node/http_api/tests/broadcast_validation_tests.rs @@ -870,11 +870,10 @@ pub async fn blinded_gossip_full_pass() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let (block_contents_tuple, _) = tester.harness.make_blinded_block(state_a, slot_b).await; - let block_contents = block_contents_tuple.into(); + let (blinded_block, _) = tester.harness.make_blinded_block(state_a, slot_b).await; let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&blinded_block, validation_level) .await; assert!(response.is_ok()); @@ -912,12 +911,11 @@ pub async fn blinded_gossip_full_pass_ssz() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let (block_contents_tuple, _) = tester.harness.make_blinded_block(state_a, slot_b).await; - let block_contents = block_contents_tuple.into(); + let (blinded_block, _) = tester.harness.make_blinded_block(state_a, slot_b).await; let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2_ssz(&block_contents, validation_level) + .post_beacon_blinded_blocks_v2_ssz(&blinded_block, validation_level) .await; assert!(response.is_ok()); @@ -1060,19 +1058,18 @@ pub async fn blinded_consensus_full_pass() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let (block_contents_tuple, _) = tester.harness.make_blinded_block(state_a, slot_b).await; + let (blinded_block, _) = tester.harness.make_blinded_block(state_a, slot_b).await; - let block_contents = block_contents_tuple.into(); let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&blinded_block, validation_level) .await; assert!(response.is_ok()); assert!(tester .harness .chain - .block_is_known_to_fork_choice(&block_contents.signed_block().canonical_root())); + .block_is_known_to_fork_choice(&blinded_block.signed_block().canonical_root())); } /// This test checks that a block that is **invalid** from a gossip perspective gets rejected when using `broadcast_validation=consensus_and_equivocation`. @@ -1159,18 +1156,13 @@ pub async fn blinded_equivocation_consensus_early_equivocation() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let (block_contents_tuple_a, state_after_a) = tester + let (block_a, state_after_a) = tester .harness .make_blinded_block(state_a.clone(), slot_b) .await; - let (block_contents_tuple_b, state_after_b) = - tester.harness.make_blinded_block(state_a, slot_b).await; + let (block_b, state_after_b) = tester.harness.make_blinded_block(state_a, slot_b).await; /* check for `make_blinded_block` curios */ - let block_contents_a: SignedBlockContents> = block_contents_tuple_a.into(); - let block_contents_b: SignedBlockContents> = block_contents_tuple_b.into(); - let block_a = block_contents_a.signed_block(); - let block_b = block_contents_b.signed_block(); assert_eq!(block_a.state_root(), state_after_a.tree_hash_root()); assert_eq!(block_b.state_root(), state_after_b.tree_hash_root()); assert_ne!(block_a.state_root(), block_b.state_root()); diff --git a/common/eth2/src/lib.rs b/common/eth2/src/lib.rs index c59e59abf5a..b3ca1d131d8 100644 --- a/common/eth2/src/lib.rs +++ b/common/eth2/src/lib.rs @@ -691,9 +691,9 @@ impl BeaconNodeHttpClient { /// `POST beacon/blocks` /// /// Returns `Ok(None)` on a 404 error. - pub async fn post_beacon_blocks>( + pub async fn post_beacon_blocks( &self, - block_contents: &SignedBlockContents, + block_contents: &SignedBlockContents, ) -> Result<(), Error> { let mut path = self.eth_path(V1)?; @@ -713,7 +713,7 @@ impl BeaconNodeHttpClient { /// Returns `Ok(None)` on a 404 error. pub async fn post_beacon_blocks_ssz>( &self, - block_contents: &SignedBlockContents, + block_contents: &SignedBlockContents, ) -> Result<(), Error> { let mut path = self.eth_path(V1)?; @@ -735,9 +735,9 @@ impl BeaconNodeHttpClient { /// `POST beacon/blinded_blocks` /// /// Returns `Ok(None)` on a 404 error. - pub async fn post_beacon_blinded_blocks>( + pub async fn post_beacon_blinded_blocks( &self, - block: &SignedBlockContents, + block: &SignedBlindedBeaconBlock, ) -> Result<(), Error> { let mut path = self.eth_path(V1)?; @@ -757,7 +757,7 @@ impl BeaconNodeHttpClient { /// Returns `Ok(None)` on a 404 error. pub async fn post_beacon_blinded_blocks_ssz>( &self, - block: &SignedBlockContents, + block: &SignedBlindedBeaconBlock, ) -> Result<(), Error> { let mut path = self.eth_path(V1)?; @@ -811,7 +811,7 @@ impl BeaconNodeHttpClient { /// `POST v2/beacon/blocks` pub async fn post_beacon_blocks_v2>( &self, - block_contents: &SignedBlockContents, + block_contents: &SignedBlockContents, validation_level: Option, ) -> Result<(), Error> { self.post_generic_with_consensus_version( @@ -828,7 +828,7 @@ impl BeaconNodeHttpClient { /// `POST v2/beacon/blocks` pub async fn post_beacon_blocks_v2_ssz>( &self, - block_contents: &SignedBlockContents, + block_contents: &SignedBlockContents, validation_level: Option, ) -> Result<(), Error> { self.post_generic_with_consensus_version_and_ssz_body( @@ -843,16 +843,16 @@ impl BeaconNodeHttpClient { } /// `POST v2/beacon/blinded_blocks` - pub async fn post_beacon_blinded_blocks_v2>( + pub async fn post_beacon_blinded_blocks_v2( &self, - block_contents: &SignedBlockContents, + signed_block: &SignedBlindedBeaconBlock, validation_level: Option, ) -> Result<(), Error> { self.post_generic_with_consensus_version( self.post_beacon_blinded_blocks_v2_path(validation_level)?, - block_contents, + signed_block, Some(self.timeouts.proposal), - block_contents.signed_block().message().body().fork_name(), + signed_block.message().body().fork_name(), ) .await?; @@ -862,14 +862,14 @@ impl BeaconNodeHttpClient { /// `POST v2/beacon/blinded_blocks` pub async fn post_beacon_blinded_blocks_v2_ssz( &self, - block_contents: &SignedBlindedBlockContents, + signed_block: &SignedBlindedBeaconBlock, validation_level: Option, ) -> Result<(), Error> { self.post_generic_with_consensus_version_and_ssz_body( self.post_beacon_blinded_blocks_v2_path(validation_level)?, - block_contents.as_ssz_bytes(), + signed_block.as_ssz_bytes(), Some(self.timeouts.proposal), - block_contents.signed_block().message().body().fork_name(), + signed_block.message().body().fork_name(), ) .await?; @@ -1622,38 +1622,33 @@ impl BeaconNodeHttpClient { } /// `GET v2/validator/blocks/{slot}` - pub async fn get_validator_blocks>( + pub async fn get_validator_blocks( &self, slot: Slot, randao_reveal: &SignatureBytes, graffiti: Option<&Graffiti>, - ) -> Result>, Error> { + ) -> Result>, Error> { self.get_validator_blocks_modular(slot, randao_reveal, graffiti, SkipRandaoVerification::No) .await } /// `GET v2/validator/blocks/{slot}` - pub async fn get_validator_blocks_modular>( + pub async fn get_validator_blocks_modular( &self, slot: Slot, randao_reveal: &SignatureBytes, graffiti: Option<&Graffiti>, skip_randao_verification: SkipRandaoVerification, - ) -> Result>, Error> { + ) -> Result>, Error> { let path = self - .get_validator_blocks_path::( - slot, - randao_reveal, - graffiti, - skip_randao_verification, - ) + .get_validator_blocks_path::(slot, randao_reveal, graffiti, skip_randao_verification) .await?; self.get(path).await } /// returns `GET v2/validator/blocks/{slot}` URL path - pub async fn get_validator_blocks_path>( + pub async fn get_validator_blocks_path( &self, slot: Slot, randao_reveal: &SignatureBytes, @@ -1739,25 +1734,25 @@ impl BeaconNodeHttpClient { if is_blinded_payload { let blinded_payload = response - .json::>>>() + .json::>>() .await?; Ok(ForkVersionedBeaconBlockType::Blinded(blinded_payload)) } else { let full_payload = response - .json::>>>() + .json::>>() .await?; Ok(ForkVersionedBeaconBlockType::Full(full_payload)) } } /// `GET v2/validator/blocks/{slot}` in ssz format - pub async fn get_validator_blocks_ssz>( + pub async fn get_validator_blocks_ssz( &self, slot: Slot, randao_reveal: &SignatureBytes, graffiti: Option<&Graffiti>, ) -> Result>, Error> { - self.get_validator_blocks_modular_ssz::( + self.get_validator_blocks_modular_ssz::( slot, randao_reveal, graffiti, @@ -1767,7 +1762,7 @@ impl BeaconNodeHttpClient { } /// `GET v2/validator/blocks/{slot}` in ssz format - pub async fn get_validator_blocks_modular_ssz>( + pub async fn get_validator_blocks_modular_ssz( &self, slot: Slot, randao_reveal: &SignatureBytes, @@ -1775,12 +1770,7 @@ impl BeaconNodeHttpClient { skip_randao_verification: SkipRandaoVerification, ) -> Result>, Error> { let path = self - .get_validator_blocks_path::( - slot, - randao_reveal, - graffiti, - skip_randao_verification, - ) + .get_validator_blocks_path::(slot, randao_reveal, graffiti, skip_randao_verification) .await?; self.get_bytes_opt_accept_header(path, Accept::Ssz, self.timeouts.get_validator_block_ssz) @@ -1788,12 +1778,12 @@ impl BeaconNodeHttpClient { } /// `GET v2/validator/blinded_blocks/{slot}` - pub async fn get_validator_blinded_blocks>( + pub async fn get_validator_blinded_blocks( &self, slot: Slot, randao_reveal: &SignatureBytes, graffiti: Option<&Graffiti>, - ) -> Result>, Error> { + ) -> Result>, Error> { self.get_validator_blinded_blocks_modular( slot, randao_reveal, @@ -1804,7 +1794,7 @@ impl BeaconNodeHttpClient { } /// returns `GET v1/validator/blinded_blocks/{slot}` URL path - pub async fn get_validator_blinded_blocks_path>( + pub async fn get_validator_blinded_blocks_path( &self, slot: Slot, randao_reveal: &SignatureBytes, @@ -1836,18 +1826,15 @@ impl BeaconNodeHttpClient { } /// `GET v1/validator/blinded_blocks/{slot}` - pub async fn get_validator_blinded_blocks_modular< - T: EthSpec, - Payload: AbstractExecPayload, - >( + pub async fn get_validator_blinded_blocks_modular( &self, slot: Slot, randao_reveal: &SignatureBytes, graffiti: Option<&Graffiti>, skip_randao_verification: SkipRandaoVerification, - ) -> Result>, Error> { + ) -> Result>, Error> { let path = self - .get_validator_blinded_blocks_path::( + .get_validator_blinded_blocks_path::( slot, randao_reveal, graffiti, @@ -1859,13 +1846,13 @@ impl BeaconNodeHttpClient { } /// `GET v2/validator/blinded_blocks/{slot}` in ssz format - pub async fn get_validator_blinded_blocks_ssz>( + 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::( + self.get_validator_blinded_blocks_modular_ssz::( slot, randao_reveal, graffiti, @@ -1874,10 +1861,7 @@ impl BeaconNodeHttpClient { .await } - pub async fn get_validator_blinded_blocks_modular_ssz< - T: EthSpec, - Payload: AbstractExecPayload, - >( + pub async fn get_validator_blinded_blocks_modular_ssz( &self, slot: Slot, randao_reveal: &SignatureBytes, @@ -1885,7 +1869,7 @@ impl BeaconNodeHttpClient { skip_randao_verification: SkipRandaoVerification, ) -> Result>, Error> { let path = self - .get_validator_blinded_blocks_path::( + .get_validator_blinded_blocks_path::( slot, randao_reveal, graffiti, diff --git a/common/eth2/src/types.rs b/common/eth2/src/types.rs index c51e5867f19..b89411ba3a1 100644 --- a/common/eth2/src/types.rs +++ b/common/eth2/src/types.rs @@ -14,8 +14,6 @@ use std::str::{from_utf8, FromStr}; use std::time::Duration; use tree_hash::TreeHash; use types::beacon_block_body::KzgCommitments; -use types::builder_bid::BlindedBlobsBundle; -use types::sidecar::BlobItems; pub use types::*; #[cfg(feature = "lighthouse")] @@ -1386,118 +1384,134 @@ pub mod serde_status_code { } } +// #[cfg(test)] +// mod tests { +// use super::*; +// use ssz::Encode; +// use std::sync::Arc; + +// #[test] +// fn query_vec() { +// assert_eq!( +// QueryVec::try_from("0,1,2".to_string()).unwrap(), +// QueryVec { +// values: vec![0_u64, 1, 2] +// } +// ); +// } + +// #[test] +// fn parse_accept_header_content() { +// assert_eq!( +// Accept::from_str("application/json; charset=utf-8").unwrap(), +// Accept::Json +// ); + +// assert_eq!( +// Accept::from_str("text/plain,application/octet-stream;q=0.3,application/json;q=0.9") +// .unwrap(), +// Accept::Json +// ); + +// assert_eq!( +// Accept::from_str("text/plain"), +// Err("accept header is not supported".to_string()) +// ); + +// assert_eq!( +// Accept::from_str("application/json;message=\"Hello, world!\";q=0.3,*/*;q=0.6").unwrap(), +// Accept::Any +// ); +// } + +// #[test] +// fn ssz_signed_block_contents_pre_deneb() { +// type E = MainnetEthSpec; +// let spec = ForkName::Capella.make_genesis_spec(E::default_spec()); + +// let block: SignedBlockContents> = SignedBeaconBlock::from_block( +// BeaconBlock::::Capella(BeaconBlockCapella::empty(&spec)), +// Signature::empty(), +// ) +// .try_into() +// .expect("should convert into signed block contents"); + +// let decoded: SignedBlockContents = +// SignedBlockContents::from_ssz_bytes(&block.as_ssz_bytes(), &spec) +// .expect("should decode Block"); +// assert!(matches!(decoded, SignedBlockContents::Block(_))); +// } + +// #[test] +// fn ssz_signed_block_contents_with_blobs() { +// type E = MainnetEthSpec; +// let spec = ForkName::Deneb.make_genesis_spec(E::default_spec()); + +// let block = SignedBeaconBlock::from_block( +// BeaconBlock::::Deneb(BeaconBlockDeneb::empty(&spec)), +// Signature::empty(), +// ); +// let blobs = SignedSidecarList::from(vec![SignedSidecar { +// message: Arc::new(BlobSidecar::empty()), +// signature: Signature::empty(), +// _phantom: Default::default(), +// }]); +// let signed_block_contents = SignedBlockContents::new(block, Some(blobs)); + +// let decoded: SignedBlockContents> = +// SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) +// .expect("should decode BlockAndBlobSidecars"); +// assert!(matches!( +// decoded, +// SignedBlockContents::BlockAndBlobSidecars(_) +// )); +// } + +// #[test] +// fn ssz_signed_blinded_block_contents_with_blobs() { +// type E = MainnetEthSpec; +// let mut spec = E::default_spec(); +// spec.altair_fork_epoch = Some(Epoch::new(0)); +// spec.bellatrix_fork_epoch = Some(Epoch::new(0)); +// spec.capella_fork_epoch = Some(Epoch::new(0)); +// spec.deneb_fork_epoch = Some(Epoch::new(0)); + +// let blinded_block = SignedBeaconBlock::from_block( +// BeaconBlock::>::Deneb(BeaconBlockDeneb::empty(&spec)), +// Signature::empty(), +// ); +// let blinded_blobs = SignedSidecarList::from(vec![SignedSidecar { +// message: Arc::new(BlindedBlobSidecar::empty()), +// signature: Signature::empty(), +// _phantom: Default::default(), +// }]); +// let signed_block_contents = SignedBlockContents::new(blinded_block, Some(blinded_blobs)); + +// let decoded: SignedBlockContents> = +// SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) +// .expect("should decode BlindedBlock"); +// assert!(matches!(decoded, SignedBlockContents::BlindedBlock(_))); +// } +// } + pub enum ForkVersionedBeaconBlockType { - Full(ForkVersionedResponse>>), - Blinded(ForkVersionedResponse>>), -} - -#[cfg(test)] -mod tests { - use super::*; - use ssz::Encode; - use std::sync::Arc; - - #[test] - fn query_vec() { - assert_eq!( - QueryVec::try_from("0,1,2".to_string()).unwrap(), - QueryVec { - values: vec![0_u64, 1, 2] - } - ); - } - - #[test] - fn parse_accept_header_content() { - assert_eq!( - Accept::from_str("application/json; charset=utf-8").unwrap(), - Accept::Json - ); - - assert_eq!( - Accept::from_str("text/plain,application/octet-stream;q=0.3,application/json;q=0.9") - .unwrap(), - Accept::Json - ); - - assert_eq!( - Accept::from_str("text/plain"), - Err("accept header is not supported".to_string()) - ); - - assert_eq!( - Accept::from_str("application/json;message=\"Hello, world!\";q=0.3,*/*;q=0.6").unwrap(), - Accept::Any - ); - } - - #[test] - fn ssz_signed_block_contents_pre_deneb() { - type E = MainnetEthSpec; - let spec = ForkName::Capella.make_genesis_spec(E::default_spec()); - - let block: SignedBlockContents> = SignedBeaconBlock::from_block( - BeaconBlock::::Capella(BeaconBlockCapella::empty(&spec)), - Signature::empty(), - ) - .try_into() - .expect("should convert into signed block contents"); - - let decoded: SignedBlockContents = - SignedBlockContents::from_ssz_bytes(&block.as_ssz_bytes(), &spec) - .expect("should decode Block"); - assert!(matches!(decoded, SignedBlockContents::Block(_))); - } - - #[test] - fn ssz_signed_block_contents_with_blobs() { - type E = MainnetEthSpec; - let spec = ForkName::Deneb.make_genesis_spec(E::default_spec()); - - let block = SignedBeaconBlock::from_block( - BeaconBlock::::Deneb(BeaconBlockDeneb::empty(&spec)), - Signature::empty(), - ); - let blobs = SignedSidecarList::from(vec![SignedSidecar { - message: Arc::new(BlobSidecar::empty()), - signature: Signature::empty(), - _phantom: Default::default(), - }]); - let signed_block_contents = SignedBlockContents::new(block, Some(blobs)); - - let decoded: SignedBlockContents> = - SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) - .expect("should decode BlockAndBlobSidecars"); - assert!(matches!( - decoded, - SignedBlockContents::BlockAndBlobSidecars(_) - )); - } - - #[test] - fn ssz_signed_blinded_block_contents_with_blobs() { - type E = MainnetEthSpec; - let mut spec = E::default_spec(); - spec.altair_fork_epoch = Some(Epoch::new(0)); - spec.bellatrix_fork_epoch = Some(Epoch::new(0)); - spec.capella_fork_epoch = Some(Epoch::new(0)); - spec.deneb_fork_epoch = Some(Epoch::new(0)); - - let blinded_block = SignedBeaconBlock::from_block( - BeaconBlock::>::Deneb(BeaconBlockDeneb::empty(&spec)), - Signature::empty(), - ); - let blinded_blobs = SignedSidecarList::from(vec![SignedSidecar { - message: Arc::new(BlindedBlobSidecar::empty()), - signature: Signature::empty(), - _phantom: Default::default(), - }]); - let signed_block_contents = SignedBlockContents::new(blinded_block, Some(blinded_blobs)); - - let decoded: SignedBlockContents> = - SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) - .expect("should decode BlindedBlock"); - assert!(matches!(decoded, SignedBlockContents::BlindedBlock(_))); + Full(ForkVersionedResponse>), + Blinded(ForkVersionedResponse>), +} + +#[derive(Debug, Encode, Serialize, Deserialize)] +#[serde(untagged)] +#[serde(bound = "E: EthSpec")] +#[ssz(enum_behaviour = "transparent")] +pub enum BlockContentsWrapper { + Full(BlockContents), + Blinded(BlindedBeaconBlock), +} + +impl BlockContentsWrapper { + /// SSZ decode with fork variant determined by slot. + pub fn from_ssz_bytes(bytes: &[u8], spec: &ChainSpec) -> Result { + todo!() } } @@ -1506,39 +1520,24 @@ mod tests { #[serde(untagged)] #[serde(bound = "T: EthSpec")] #[ssz(enum_behaviour = "transparent")] -pub enum BlockContents> { - /// This is a full deneb variant with blobs. - BlockAndBlobSidecars(BeaconBlockAndBlobSidecars), - /// This variant is for all pre-deneb blinded and unblinded and deneb blinded. - Block(BeaconBlock), -} - -pub type BlockContentsTuple = ( - BeaconBlock, - Option<( - KzgProofs, - <>::Sidecar as Sidecar>::BlobItems, - )>, -); - -impl> BlockContents { - pub fn new( - block: BeaconBlock, - blob_data: Option<(KzgProofs, >::BlobItems)>, - ) -> Self { - match (Payload::block_type(), blob_data) { - (BlockType::Full, Some((kzg_proofs, blobs))) => { - Self::BlockAndBlobSidecars(BeaconBlockAndBlobSidecars { - block, - kzg_proofs, - blobs, - }) - } - // Blinded blocks with blobs do not make sense as a variant - // TODO(pawan): return an error or rethink this - // just dropping the blobs for now - (BlockType::Blinded, Some(_blobs)) => Self::Block(block), - (_, None) => Self::Block(block), +pub enum BlockContents { + /// This is a full deneb variant with block and blobs. + BlockAndBlobSidecars(BeaconBlockAndBlobSidecars), + /// This variant is for all pre-deneb full blocks. + Block(BeaconBlock), +} + +pub type BlockContentsTuple = (BeaconBlock, Option<(KzgProofs, BlobsList)>); + +impl BlockContents { + pub fn new(block: BeaconBlock, blob_data: Option<(KzgProofs, BlobsList)>) -> Self { + match blob_data { + Some((kzg_proofs, blobs)) => Self::BlockAndBlobSidecars(BeaconBlockAndBlobSidecars { + block, + kzg_proofs, + blobs, + }), + None => Self::Block(block), } } @@ -1559,41 +1558,36 @@ impl> BlockContents { ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { BeaconBlock::from_ssz_bytes(bytes, spec).map(|block| BlockContents::Block(block)) } - ForkName::Deneb => match Payload::block_type() { - BlockType::Blinded => BeaconBlock::from_ssz_bytes(bytes, spec) - .map(|block| BlockContents::Block(block)), - BlockType::Full => { - // The `Full`` variant **must** contains blobs and proofs - let mut builder = ssz::SszDecoderBuilder::new(bytes); - - // TODO(pawan): potential bug - builder.register_anonymous_variable_length_item()?; - builder.register_type::>()?; - - builder.register_anonymous_variable_length_item()?; - builder.register_type::>()?; - - let mut decoder = builder.build()?; - let block = decoder - .decode_next_with(|bytes| BeaconBlock::from_ssz_bytes(bytes, spec))?; - let kzg_proofs = - decoder.decode_next_with(|bytes| KzgProofs::::from_ssz_bytes(bytes))?; - let blobs = decoder.decode_next()?; - - Ok(BlockContents::new(block, Some((kzg_proofs, blobs)))) - } - }, + ForkName::Deneb => { + let mut builder = ssz::SszDecoderBuilder::new(bytes); + + // TODO(pawan): potential bug + builder.register_anonymous_variable_length_item()?; + builder.register_type::>()?; + + builder.register_anonymous_variable_length_item()?; + builder.register_type::>()?; + + let mut decoder = builder.build()?; + let block = + decoder.decode_next_with(|bytes| BeaconBlock::from_ssz_bytes(bytes, spec))?; + let kzg_proofs = + decoder.decode_next_with(|bytes| KzgProofs::::from_ssz_bytes(bytes))?; + let blobs = decoder.decode_next()?; + + Ok(BlockContents::new(block, Some((kzg_proofs, blobs)))) + } } } - pub fn block(&self) -> &BeaconBlock { + pub fn block(&self) -> &BeaconBlock { match self { BlockContents::BlockAndBlobSidecars(block_and_sidecars) => &block_and_sidecars.block, BlockContents::Block(block) => block, } } - pub fn deconstruct(self) -> BlockContentsTuple { + pub fn deconstruct(self) -> BlockContentsTuple { match self { BlockContents::BlockAndBlobSidecars(block_and_sidecars) => ( block_and_sidecars.block, @@ -1610,16 +1604,14 @@ impl> BlockContents { fork: &Fork, genesis_validators_root: Hash256, spec: &ChainSpec, - ) -> SignedBlockContents { + ) -> SignedBlockContents { let (block, maybe_blobs) = self.deconstruct(); let signed_block = block.sign(secret_key, fork, genesis_validators_root, spec); SignedBlockContents::new(signed_block, maybe_blobs) } } -impl> ForkVersionDeserialize - for BlockContents -{ +impl ForkVersionDeserialize for BlockContents { fn deserialize_by_fork<'de, D: serde::Deserializer<'de>>( value: serde_json::value::Value, fork_name: ForkName, @@ -1631,28 +1623,15 @@ impl> ForkVersionDeserialize D, >(value, fork_name)?)) } - ForkName::Deneb => { - let block_contents = - match Payload::block_type() { - BlockType::Blinded => BlockContents::Block( - BeaconBlock::deserialize_by_fork::<'de, D>(value, fork_name)?, - ), - BlockType::Full => BlockContents::BlockAndBlobSidecars( - BeaconBlockAndBlobSidecars::deserialize_by_fork::<'de, D>( - value, fork_name, - )?, - ), - }; - Ok(block_contents) - } + ForkName::Deneb => Ok(BlockContents::BlockAndBlobSidecars( + BeaconBlockAndBlobSidecars::deserialize_by_fork::<'de, D>(value, fork_name)?, + )), } } } -impl> Into> - for BlockContents -{ - fn into(self) -> BeaconBlock { +impl Into> for BlockContents { + fn into(self) -> BeaconBlock { match self { Self::BlockAndBlobSidecars(block_and_sidecars) => block_and_sidecars.block, Self::Block(block) => block, @@ -1660,49 +1639,32 @@ impl> Into> } } -pub type SignedBlockContentsTuple = ( - SignedBeaconBlock, - Option<( - KzgProofs, - <>::Sidecar as Sidecar>::BlobItems, - )>, -); - -pub type SignedBlindedBlockContents = SignedBlockContents>; +pub type SignedBlockContentsTuple = (SignedBeaconBlock, Option<(KzgProofs, BlobsList)>); /// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobSidecars`]. #[derive(Clone, Debug, Encode, Serialize, Deserialize)] #[serde(untagged)] #[serde(bound = "T: EthSpec")] #[ssz(enum_behaviour = "transparent")] -pub enum SignedBlockContents = FullPayload> { - BlockAndBlobSidecars(SignedBeaconBlockAndBlobSidecars), - // TODO(pawan): double check that having just one variant for - // deneb blinded flow + pre-deneb blinded and unblinded flow makes sense - Block(SignedBeaconBlock), +pub enum SignedBlockContents { + BlockAndBlobSidecars(SignedBeaconBlockAndBlobSidecars), + Block(SignedBeaconBlock), } -impl> SignedBlockContents { +impl SignedBlockContents { pub fn new( - block: SignedBeaconBlock, - blob_items: Option<(KzgProofs, >::BlobItems)>, + block: SignedBeaconBlock, + blob_items: Option<(KzgProofs, BlobsList)>, ) -> Self { - match (Payload::block_type(), blob_items) { - (BlockType::Full, Some((kzg_proofs, blobs))) => { + match blob_items { + Some((kzg_proofs, blobs)) => { Self::BlockAndBlobSidecars(SignedBeaconBlockAndBlobSidecars { signed_block: block, kzg_proofs, blobs, }) } - (BlockType::Blinded, Some(_blobs)) => { - // Blinded blocks with blobs do not make sense as a variant - // TODO(pawan): return an error or rethink this - // just dropping the blobs for now - Self::Block(block) - } - - (_, None) => Self::Block(block), + None => Self::Block(block), } } @@ -1724,29 +1686,25 @@ impl> SignedBlockContents match Payload::block_type() { - BlockType::Blinded => SignedBeaconBlock::from_ssz_bytes(bytes, spec) - .map(|block| SignedBlockContents::Block(block)), - BlockType::Full => { - let mut builder = ssz::SszDecoderBuilder::new(bytes); - builder.register_anonymous_variable_length_item()?; - builder.register_type::>()?; - - builder.register_anonymous_variable_length_item()?; - builder.register_type::>()?; - - let mut decoder = builder.build()?; - let block = decoder - .decode_next_with(|bytes| SignedBeaconBlock::from_ssz_bytes(bytes, spec))?; - let kzg_proofs = decoder.decode_next()?; - let blobs = decoder.decode_next()?; - Ok(SignedBlockContents::new(block, Some((kzg_proofs, blobs)))) - } - }, + ForkName::Deneb => { + let mut builder = ssz::SszDecoderBuilder::new(bytes); + builder.register_anonymous_variable_length_item()?; + builder.register_type::>()?; + + builder.register_anonymous_variable_length_item()?; + builder.register_type::>()?; + + let mut decoder = builder.build()?; + let block = decoder + .decode_next_with(|bytes| SignedBeaconBlock::from_ssz_bytes(bytes, spec))?; + let kzg_proofs = decoder.decode_next()?; + let blobs = decoder.decode_next()?; + Ok(SignedBlockContents::new(block, Some((kzg_proofs, blobs)))) + } } } - pub fn signed_block(&self) -> &SignedBeaconBlock { + pub fn signed_block(&self) -> &SignedBeaconBlock { match self { SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => { &block_and_sidecars.signed_block @@ -1755,34 +1713,19 @@ impl> SignedBlockContents Option> { - match self { - SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => { - block_and_sidecars.blobs.blobs().cloned() - } - SignedBlockContents::Block(_block) => None, - } - } - pub fn blobs_sidecar_list(&self) -> Option> { match self { SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => { - let blobs = block_and_sidecars.blobs.blobs().cloned()?; + let blobs = block_and_sidecars.blobs.clone(); let block = &block_and_sidecars.signed_block; let kzg_commitments = block.message().body().blob_kzg_commitments().ok()?; - Sidecar::build_sidecar( - blobs, - self.signed_block(), - kzg_commitments, - block_and_sidecars.kzg_proofs.clone().into(), - ) - .ok() + todo!() } SignedBlockContents::Block(_block) => None, } } - pub fn deconstruct(self) -> SignedBlockContentsTuple { + pub fn deconstruct(self) -> SignedBlockContentsTuple { match self { SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => ( block_and_sidecars.signed_block, @@ -1793,67 +1736,45 @@ impl> SignedBlockContents SignedBlockContents> { - /// Converting from a Blinded - pub fn try_into_full_block_and_blobs( - self, - maybe_full_payload_contents: Option>, - ) -> Result>, String> { - match self { - SignedBlockContents::BlockAndBlobSidecars(_) => Err( - "BlockAndBlobSidecars variant not expected when constructing full block" - .to_string(), - ), - SignedBlockContents::Block(blinded_block) => { - match maybe_full_payload_contents { - None => { - Err("Can't build full block contents without payload and blobs".to_string()) - } - // This variant implies a pre-deneb block - Some(FullPayloadContents::Payload(execution_payload)) => { - let signed_block = blinded_block - .try_into_full_block(Some(execution_payload)) - .ok_or("Failed to build full block with payload".to_string())?; - Ok(SignedBlockContents::new(signed_block, None)) - } - // This variant implies a post-deneb block - Some(FullPayloadContents::PayloadAndBlobs(payload_and_blobs)) => { - let signed_block = blinded_block - .try_into_full_block(Some(payload_and_blobs.execution_payload)) - .ok_or("Failed to build full block with payload".to_string())?; - - Ok(SignedBlockContents::new( - signed_block, - Some(( - payload_and_blobs.blobs_bundle.proofs, - payload_and_blobs.blobs_bundle.blobs, - )), - )) - } - } - } +/// Converting from a Blinded +pub fn into_full_block_and_blobs( + blinded_block: SignedBlindedBeaconBlock, + maybe_full_payload_contents: Option>, +) -> Result, String> { + match maybe_full_payload_contents { + None => { + let signed_block = blinded_block + .try_into_full_block(None) + .ok_or("Failed to build full block with payload".to_string())?; + Ok(SignedBlockContents::new(signed_block, None)) + } + // This variant implies a pre-deneb block + Some(FullPayloadContents::Payload(execution_payload)) => { + let signed_block = blinded_block + .try_into_full_block(Some(execution_payload)) + .ok_or("Failed to build full block with payload".to_string())?; + Ok(SignedBlockContents::new(signed_block, None)) + } + // This variant implies a post-deneb block + Some(FullPayloadContents::PayloadAndBlobs(payload_and_blobs)) => { + let signed_block = blinded_block + .try_into_full_block(Some(payload_and_blobs.execution_payload)) + .ok_or("Failed to build full block with payload".to_string())?; + + Ok(SignedBlockContents::new( + signed_block, + Some(( + payload_and_blobs.blobs_bundle.proofs, + payload_and_blobs.blobs_bundle.blobs, + )), + )) } } } -// impl SignedBlockContents { -// pub fn clone_as_blinded(&self) -> SignedBlindedBlockContents { -// let blinded_blobs = self.blobs_cloned().map(|blob_sidecars| { -// blob_sidecars -// .into_iter() -// .map(|blob| Arc::new(blob.into())) -// .collect::>() -// .into() -// }); -// SignedBlockContents::new(self.signed_block().clone_as_blinded(), blinded_blobs) -// } -// } - -impl> TryFrom> - for SignedBlockContents -{ +impl TryFrom> for SignedBlockContents { type Error = &'static str; - fn try_from(block: SignedBeaconBlock) -> Result { + fn try_from(block: SignedBeaconBlock) -> Result { match block { SignedBeaconBlock::Base(_) | SignedBeaconBlock::Altair(_) @@ -1866,48 +1787,41 @@ impl> TryFrom> From> - for SignedBlockContents -{ - fn from(block_contents_tuple: SignedBlockContentsTuple) -> Self { +impl From> for SignedBlockContents { + fn from(block_contents_tuple: SignedBlockContentsTuple) -> Self { SignedBlockContents::new(block_contents_tuple.0, block_contents_tuple.1) } } -/// Note: This does not have a blinded variant, so we fix the payload to `Full`. #[derive(Debug, Clone, Serialize, Deserialize, Encode)] #[serde(bound = "T: EthSpec")] -pub struct SignedBeaconBlockAndBlobSidecars> { - pub signed_block: SignedBeaconBlock, +pub struct SignedBeaconBlockAndBlobSidecars { + pub signed_block: SignedBeaconBlock, pub kzg_proofs: KzgProofs, - pub blobs: >::BlobItems, + pub blobs: BlobsList, } -/// Note: This does not have a blinded variant, so we fix the payload to `Full`. #[derive(Debug, Clone, Serialize, Deserialize, Encode)] #[serde(bound = "T: EthSpec")] -pub struct BeaconBlockAndBlobSidecars> { - pub block: BeaconBlock, +pub struct BeaconBlockAndBlobSidecars { + pub block: BeaconBlock, pub kzg_proofs: KzgProofs, - pub blobs: >::BlobItems, + pub blobs: BlobsList, } -impl> ForkVersionDeserialize - for BeaconBlockAndBlobSidecars -{ +impl ForkVersionDeserialize for BeaconBlockAndBlobSidecars { fn deserialize_by_fork<'de, D: serde::Deserializer<'de>>( value: serde_json::value::Value, fork_name: ForkName, ) -> Result { #[derive(Deserialize)] #[serde(bound = "T: EthSpec")] - struct Helper> { + struct Helper { block: serde_json::Value, kzg_proofs: KzgProofs, - blobs: S::BlobItems, + blobs: BlobsList, } - let helper: Helper = - serde_json::from_value(value).map_err(serde::de::Error::custom)?; + let helper: Helper = serde_json::from_value(value).map_err(serde::de::Error::custom)?; Ok(Self { block: BeaconBlock::deserialize_by_fork::<'de, D>(helper.block, fork_name)?, @@ -1998,18 +1912,3 @@ pub struct BlobsBundle { #[serde(with = "ssz_types::serde_utils::list_of_hex_fixed_vec")] pub blobs: BlobsList, } - -impl Into> for BlobsBundle { - fn into(self) -> BlindedBlobsBundle { - BlindedBlobsBundle { - commitments: self.commitments, - proofs: self.proofs, - blob_roots: self - .blobs - .into_iter() - .map(|blob| blob.tree_hash_root()) - .collect::>() - .into(), - } - } -} diff --git a/consensus/types/src/blob_sidecar.rs b/consensus/types/src/blob_sidecar.rs index c4e52d8056f..100bee56dbd 100644 --- a/consensus/types/src/blob_sidecar.rs +++ b/consensus/types/src/blob_sidecar.rs @@ -78,32 +78,6 @@ pub struct BlobSidecar { pub kzg_commitment_inclusion_proof: FixedVector, } -impl From>> for BlindedBlobSidecar { - fn from(blob_sidecar: Arc>) -> Self { - BlindedBlobSidecar { - index: blob_sidecar.index, - blob_root: blob_sidecar.blob.tree_hash_root(), - kzg_commitment: blob_sidecar.kzg_commitment, - kzg_proof: blob_sidecar.kzg_proof, - signed_block_header: blob_sidecar.signed_block_header.clone(), - kzg_commitment_inclusion_proof: blob_sidecar.kzg_commitment_inclusion_proof.clone(), - } - } -} - -impl From> for BlindedBlobSidecar { - fn from(blob_sidecar: BlobSidecar) -> Self { - BlindedBlobSidecar { - index: blob_sidecar.index, - blob_root: blob_sidecar.blob.tree_hash_root(), - kzg_commitment: blob_sidecar.kzg_commitment, - kzg_proof: blob_sidecar.kzg_proof, - signed_block_header: blob_sidecar.signed_block_header, - kzg_commitment_inclusion_proof: blob_sidecar.kzg_commitment_inclusion_proof, - } - } -} - impl PartialOrd for BlobSidecar { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) @@ -204,72 +178,8 @@ impl BlobSidecar { } } -#[derive( - Debug, - Clone, - Serialize, - Deserialize, - Encode, - Decode, - TreeHash, - TestRandom, - Derivative, - arbitrary::Arbitrary, -)] -#[serde(bound = "T: EthSpec")] -#[arbitrary(bound = "T: EthSpec")] -#[derivative(PartialEq, Eq, Hash(bound = "T: EthSpec"))] -pub struct BlindedBlobSidecar { - #[serde(with = "serde_utils::quoted_u64")] - pub index: u64, - pub blob_root: Hash256, - pub kzg_commitment: KzgCommitment, - pub kzg_proof: KzgProof, - pub signed_block_header: SignedBeaconBlockHeader, - pub kzg_commitment_inclusion_proof: FixedVector, -} - -impl BlindedBlobSidecar { - pub fn empty() -> Self { - Self { - index: 0, - blob_root: Hash256::zero(), - kzg_commitment: KzgCommitment::empty_for_testing(), - kzg_proof: KzgProof::empty(), - kzg_commitment_inclusion_proof: Default::default(), - // TODO(pawan): make default impl - signed_block_header: SignedBeaconBlockHeader { - message: BeaconBlockHeader { - body_root: Default::default(), - parent_root: Default::default(), - proposer_index: Default::default(), - slot: Default::default(), - state_root: Default::default(), - }, - signature: Signature::empty(), - }, - } - } - // TODO(pawan): recheck if we want to impl this function on a different type alias - pub fn into_full_blob_sidecars(self: Arc, blob: Blob) -> Arc> { - let blinded_sidecar = self; - Arc::new(BlobSidecar { - index: blinded_sidecar.index, - blob, - kzg_commitment: blinded_sidecar.kzg_commitment, - kzg_proof: blinded_sidecar.kzg_proof, - kzg_commitment_inclusion_proof: blinded_sidecar.kzg_commitment_inclusion_proof.clone(), - signed_block_header: blinded_sidecar.signed_block_header.clone(), - }) - } -} - pub type SidecarList = VariableList, ::MaxBlobsPerBlock>; pub type BlobSidecarList = SidecarList>; -pub type BlindedBlobSidecarList = SidecarList>; - pub type FixedBlobSidecarList = FixedVector>>, ::MaxBlobsPerBlock>; - pub type BlobsList = VariableList, ::MaxBlobCommitmentsPerBlock>; -pub type BlobRootsList = VariableList::MaxBlobCommitmentsPerBlock>; diff --git a/consensus/types/src/builder_bid.rs b/consensus/types/src/builder_bid.rs index 910ef97c71c..bf9d1fbe8ad 100644 --- a/consensus/types/src/builder_bid.rs +++ b/consensus/types/src/builder_bid.rs @@ -1,24 +1,15 @@ use crate::beacon_block_body::KzgCommitments; use crate::{ - BlobRootsList, ChainSpec, EthSpec, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, + ChainSpec, EthSpec, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderMerge, ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, ForkName, ForkVersionDeserialize, KzgProofs, SignedRoot, Uint256, }; use bls::PublicKeyBytes; use bls::Signature; use serde::{Deserialize, Deserializer, Serialize}; -use ssz_derive::Encode; use superstruct::superstruct; use tree_hash_derive::TreeHash; -#[derive(PartialEq, Debug, Default, Serialize, Deserialize, TreeHash, Clone, Encode)] -#[serde(bound = "E: EthSpec")] -pub struct BlindedBlobsBundle { - pub commitments: KzgCommitments, - pub proofs: KzgProofs, - pub blob_roots: BlobRootsList, -} - #[superstruct( variants(Merge, Capella, Deneb), variant_attributes( @@ -39,7 +30,7 @@ pub struct BuilderBid { #[superstruct(only(Deneb), partial_getter(rename = "header_deneb"))] pub header: ExecutionPayloadHeaderDeneb, #[superstruct(only(Deneb))] - pub blinded_blobs_bundle: BlindedBlobsBundle, + pub blob_kzg_commitments: KzgCommitments, #[serde(with = "serde_utils::quoted_u256")] pub value: Uint256, pub pubkey: PublicKeyBytes, diff --git a/consensus/types/src/lib.rs b/consensus/types/src/lib.rs index f2dc753a3d7..82f8e50e5b5 100644 --- a/consensus/types/src/lib.rs +++ b/consensus/types/src/lib.rs @@ -99,7 +99,6 @@ pub mod slot_data; pub mod sqlite; pub mod blob_sidecar; -pub mod sidecar; use ethereum_types::{H160, H256}; @@ -119,10 +118,7 @@ pub use crate::beacon_block_body::{ pub use crate::beacon_block_header::BeaconBlockHeader; pub use crate::beacon_committee::{BeaconCommittee, OwnedBeaconCommittee}; pub use crate::beacon_state::{BeaconTreeHashCache, Error as BeaconStateError, *}; -pub use crate::blob_sidecar::{ - BlindedBlobSidecar, BlindedBlobSidecarList, BlobRootsList, BlobSidecar, BlobSidecarList, - BlobsList, SidecarList, -}; +pub use crate::blob_sidecar::{BlobSidecar, BlobSidecarList, BlobsList, SidecarList}; pub use crate::bls_to_execution_change::BlsToExecutionChange; pub use crate::chain_spec::{ChainSpec, Config, Domain}; pub use crate::checkpoint::Checkpoint; @@ -217,6 +213,5 @@ pub use bls::{ pub use kzg::{KzgCommitment, KzgProof}; -pub use sidecar::Sidecar; pub use ssz_types::{typenum, typenum::Unsigned, BitList, BitVector, FixedVector, VariableList}; pub use superstruct::superstruct; diff --git a/consensus/types/src/payload.rs b/consensus/types/src/payload.rs index 6f96d15518d..c19a98db336 100644 --- a/consensus/types/src/payload.rs +++ b/consensus/types/src/payload.rs @@ -83,8 +83,6 @@ pub trait AbstractExecPayload: + TryInto + TryInto { - type Sidecar: Sidecar; - type Ref<'a>: ExecPayload + Copy + From<&'a Self::Merge> @@ -105,9 +103,6 @@ pub trait AbstractExecPayload: + TryFrom>; fn default_at_fork(fork_name: ForkName) -> Result; - fn default_blobs_at_fork( - fork_name: ForkName, - ) -> Result<>::BlobItems, Error>; } #[superstruct( @@ -384,7 +379,6 @@ impl<'b, T: EthSpec> ExecPayload for FullPayloadRef<'b, T> { } impl AbstractExecPayload for FullPayload { - type Sidecar = BlobSidecar; type Ref<'a> = FullPayloadRef<'a, T>; type Merge = FullPayloadMerge; type Capella = FullPayloadCapella; @@ -398,14 +392,6 @@ impl AbstractExecPayload for FullPayload { ForkName::Deneb => Ok(FullPayloadDeneb::default().into()), } } - fn default_blobs_at_fork(fork_name: ForkName) -> Result, Error> { - match fork_name { - ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { - Err(Error::IncorrectStateVariant) - } - ForkName::Deneb => Ok(VariableList::default()), - } - } } impl From> for FullPayload { @@ -911,8 +897,6 @@ impl AbstractExecPayload for BlindedPayload { type Capella = BlindedPayloadCapella; type Deneb = BlindedPayloadDeneb; - type Sidecar = BlindedBlobSidecar; - fn default_at_fork(fork_name: ForkName) -> Result { match fork_name { ForkName::Base | ForkName::Altair => Err(Error::IncorrectStateVariant), @@ -921,14 +905,6 @@ impl AbstractExecPayload for BlindedPayload { ForkName::Deneb => Ok(BlindedPayloadDeneb::default().into()), } } - fn default_blobs_at_fork(fork_name: ForkName) -> Result, Error> { - match fork_name { - ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { - Err(Error::IncorrectStateVariant) - } - ForkName::Deneb => Ok(VariableList::default()), - } - } } impl From> for BlindedPayload { diff --git a/consensus/types/src/sidecar.rs b/consensus/types/src/sidecar.rs deleted file mode 100644 index 364ec989aab..00000000000 --- a/consensus/types/src/sidecar.rs +++ /dev/null @@ -1,191 +0,0 @@ -use crate::beacon_block_body::KzgCommitments; -use crate::test_utils::TestRandom; -use crate::{ - AbstractExecPayload, BlindedBlobSidecar, BlindedBlobSidecarList, BlobRootsList, BlobSidecar, - BlobSidecarList, BlobsList, EthSpec, SidecarList, SignedBeaconBlock, Slot, -}; -use kzg::KzgProof; -use serde::de::DeserializeOwned; -use serde::{Deserialize, Serialize}; -use ssz::{Decode, Encode}; -use ssz_types::VariableList; -use std::fmt::Debug; -use std::hash::Hash; -use std::sync::Arc; -use tree_hash::TreeHash; - -pub trait Sidecar: - serde::Serialize - + Clone - + DeserializeOwned - + Encode - + Decode - + Hash - + TreeHash - + TestRandom - + Debug - + Sync - + Send - + for<'a> arbitrary::Arbitrary<'a> -{ - type BlobItems: BlobItems; - - fn slot(&self) -> Slot; - - fn build_sidecar>( - blob_items: Self::BlobItems, - block: &SignedBeaconBlock, - expected_kzg_commitments: &KzgCommitments, - kzg_proofs: Vec, - ) -> Result, String>; -} - -pub trait BlobItems: - Sync + Send + Sized + Debug + Clone + Encode + Decode + Serialize + for<'a> Deserialize<'a> -{ - fn try_from_blob_roots(roots: BlobRootsList) -> Result; - fn try_from_blobs(blobs: BlobsList) -> Result; - fn len(&self) -> usize; - fn is_empty(&self) -> bool; - fn blobs(&self) -> Option<&BlobsList>; -} - -impl BlobItems for BlobsList { - fn try_from_blob_roots(_roots: BlobRootsList) -> Result { - Err("Unexpected conversion from blob roots to blobs".to_string()) - } - - fn try_from_blobs(blobs: BlobsList) -> Result { - Ok(blobs) - } - - fn len(&self) -> usize { - VariableList::len(self) - } - - fn is_empty(&self) -> bool { - VariableList::is_empty(self) - } - - fn blobs(&self) -> Option<&BlobsList> { - Some(self) - } -} - -impl BlobItems for BlobRootsList { - fn try_from_blob_roots(roots: BlobRootsList) -> Result { - Ok(roots) - } - - fn try_from_blobs(blobs: BlobsList) -> Result { - VariableList::new( - blobs - .into_iter() - .map(|blob| blob.tree_hash_root()) - .collect(), - ) - .map_err(|e| format!("{e:?}")) - } - - fn len(&self) -> usize { - VariableList::len(self) - } - - fn is_empty(&self) -> bool { - VariableList::is_empty(self) - } - - fn blobs(&self) -> Option<&BlobsList> { - None - } -} - -impl Sidecar for BlobSidecar { - type BlobItems = BlobsList; - - fn slot(&self) -> Slot { - self.signed_block_header.message.slot - } - - fn build_sidecar>( - blobs: BlobsList, - block: &SignedBeaconBlock, - expected_kzg_commitments: &KzgCommitments, - kzg_proofs: Vec, - ) -> Result, String> { - let blob_sidecars = BlobSidecarList::from( - blobs - .into_iter() - .enumerate() - .map(|(blob_index, blob)| { - let kzg_commitment = expected_kzg_commitments - .get(blob_index) - .ok_or("KZG commitment should exist for blob")?; - - let kzg_proof = kzg_proofs - .get(blob_index) - .ok_or("KZG proof should exist for blob")?; - - Ok(Arc::new(BlobSidecar { - index: blob_index as u64, - blob, - kzg_commitment: *kzg_commitment, - kzg_proof: *kzg_proof, - signed_block_header: block.signed_block_header(), - kzg_commitment_inclusion_proof: block - .kzg_commitment_merkle_proof(blob_index) - .ok_or_else(|| "KzgCommitment inclusion proof not available")?, - })) - }) - .collect::, String>>()?, - ); - - Ok(blob_sidecars) - } -} - -impl Sidecar for BlindedBlobSidecar { - type BlobItems = BlobRootsList; - - fn slot(&self) -> Slot { - self.signed_block_header.message.slot - } - - fn build_sidecar>( - blob_roots: BlobRootsList, - block: &SignedBeaconBlock, - expected_kzg_commitments: &KzgCommitments, - kzg_proofs: Vec, - ) -> Result>, String> { - let blob_sidecars = BlindedBlobSidecarList::::from( - blob_roots - .into_iter() - .enumerate() - .map(|(blob_index, blob_root)| { - let kzg_commitment = expected_kzg_commitments - .get(blob_index) - .ok_or("KZG commitment should exist for blob")?; - - let kzg_proof = kzg_proofs.get(blob_index).ok_or(format!( - "Missing KZG proof for slot {} blob index: {}", - block.slot(), - blob_index - ))?; - - Ok(Arc::new(BlindedBlobSidecar { - index: blob_index as u64, - blob_root, - kzg_commitment: *kzg_commitment, - kzg_proof: *kzg_proof, - signed_block_header: block.signed_block_header(), - kzg_commitment_inclusion_proof: block - .kzg_commitment_merkle_proof(blob_index) - .ok_or_else(|| "KzgCommitment inclusion proof not available")?, - })) - }) - .collect::, String>>()?, - ); - - Ok(blob_sidecars) - } -} diff --git a/validator_client/src/block_service.rs b/validator_client/src/block_service.rs index 851a7141a3a..470d49d344f 100644 --- a/validator_client/src/block_service.rs +++ b/validator_client/src/block_service.rs @@ -23,8 +23,7 @@ use std::time::Duration; use tokio::sync::mpsc; use tokio::time::sleep; use types::{ - AbstractExecPayload, BlindedPayload, BlockType, EthSpec, FullPayload, Graffiti, PublicKeyBytes, - Slot, + BlindedBeaconBlock, EthSpec, Graffiti, PublicKeyBytes, SignedBlindedBeaconBlock, Slot, }; #[derive(Debug)] @@ -346,7 +345,7 @@ impl BlockService { if builder_proposals { let result = service .clone() - .publish_block::>(slot, validator_pubkey) + .publish_block(slot, validator_pubkey, true) .await; match result { Err(BlockError::Recoverable(e)) => { @@ -357,9 +356,8 @@ impl BlockService { "block_slot" => ?slot, "info" => "blinded proposal failed, attempting full block" ); - if let Err(e) = service - .publish_block::>(slot, validator_pubkey) - .await + if let Err(e) = + service.publish_block(slot, validator_pubkey, false).await { // Log a `crit` since a full block // (non-builder) proposal failed. @@ -386,9 +384,8 @@ impl BlockService { } Ok(_) => {} }; - } else if let Err(e) = service - .publish_block::>(slot, validator_pubkey) - .await + } else if let Err(e) = + service.publish_block(slot, validator_pubkey, false).await { // Log a `crit` since a full block (non-builder) // proposal failed. @@ -409,10 +406,11 @@ impl BlockService { } /// Produce a block at the given slot for validator_pubkey - async fn publish_block>( + async fn publish_block( self, slot: Slot, validator_pubkey: PublicKeyBytes, + builder_proposal: bool, ) -> Result<(), BlockError> { let log = self.context.log(); let _timer = @@ -475,7 +473,7 @@ impl BlockService { // // Try the proposer nodes last, since it's likely that they don't have a // great view of attestations on the network. - let block_contents = proposer_fallback + let unsigned_block = proposer_fallback .first_success_try_proposers_last( RequireSynced::No, OfflineOnFailure::Yes, @@ -486,20 +484,32 @@ impl BlockService { randao_reveal_ref, graffiti, proposer_index, + builder_proposal, log, ) }, ) .await?; - let (block, blob_items) = block_contents.deconstruct(); let signing_timer = metrics::start_timer(&metrics::BLOCK_SIGNING_TIMES); - let signed_block = match self_ref - .validator_store - .sign_block::(*validator_pubkey_ref, block, current_slot) - .await - { + let res = match unsigned_block { + UnsignedBlock::Full(block_contents) => { + let (block, maybe_blobs) = block_contents.deconstruct(); + self_ref + .validator_store + .sign_block(*validator_pubkey_ref, block, current_slot) + .await + .map(|b| SignedBlock::Full(SignedBlockContents::new(b, maybe_blobs))) + } + UnsignedBlock::Blinded(block) => self_ref + .validator_store + .sign_block(*validator_pubkey_ref, block, current_slot) + .await + .map(SignedBlock::Blinded), + }; + + let signed_block = match res { Ok(block) => block, Err(ValidatorStoreError::UnknownPubkey(pubkey)) => { // A pubkey can be missing when a validator was recently removed @@ -531,8 +541,6 @@ impl BlockService { "signing_time_ms" => signing_time_ms, ); - let signed_block_contents = SignedBlockContents::from((signed_block, blob_items)); - // Publish block with first available beacon node. // // Try the proposer nodes first, since we've likely gone to efforts to @@ -543,11 +551,8 @@ impl BlockService { RequireSynced::No, OfflineOnFailure::Yes, |beacon_node| async { - self.publish_signed_block_contents::( - &signed_block_contents, - beacon_node, - ) - .await + self.publish_signed_block_contents(&signed_block, beacon_node) + .await }, ) .await?; @@ -555,41 +560,41 @@ impl BlockService { info!( log, "Successfully published block"; - "block_type" => ?Payload::block_type(), - "deposits" => signed_block_contents.signed_block().message().body().deposits().len(), - "attestations" => signed_block_contents.signed_block().message().body().attestations().len(), + "builder_proposal" => builder_proposal, + "deposits" => signed_block.num_deposits(), + "attestations" => signed_block.num_attestations(), "graffiti" => ?graffiti.map(|g| g.as_utf8_lossy()), - "slot" => signed_block_contents.signed_block().slot().as_u64(), + "slot" => signed_block.slot().as_u64(), ); Ok(()) } - async fn publish_signed_block_contents>( + async fn publish_signed_block_contents( &self, - signed_block_contents: &SignedBlockContents, + signed_block: &SignedBlock, beacon_node: &BeaconNodeHttpClient, ) -> Result<(), BlockError> { let log = self.context.log(); - let slot = signed_block_contents.signed_block().slot(); - match Payload::block_type() { - BlockType::Full => { + let slot = signed_block.slot(); + match signed_block { + SignedBlock::Full(signed_block) => { let _post_timer = metrics::start_timer_vec( &metrics::BLOCK_SERVICE_TIMES, &[metrics::BEACON_BLOCK_HTTP_POST], ); beacon_node - .post_beacon_blocks(signed_block_contents) + .post_beacon_blocks(signed_block) .await .or_else(|e| handle_block_post_error(e, slot, log))? } - BlockType::Blinded => { + SignedBlock::Blinded(signed_block) => { let _post_timer = metrics::start_timer_vec( &metrics::BLOCK_SERVICE_TIMES, &[metrics::BLINDED_BEACON_BLOCK_HTTP_POST], ); beacon_node - .post_beacon_blinded_blocks(signed_block_contents) + .post_beacon_blinded_blocks(signed_block) .await .or_else(|e| handle_block_post_error(e, slot, log))? } @@ -597,22 +602,23 @@ impl BlockService { Ok::<_, BlockError>(()) } - async fn get_validator_block>( + async fn get_validator_block( beacon_node: &BeaconNodeHttpClient, slot: Slot, randao_reveal_ref: &SignatureBytes, graffiti: Option, proposer_index: Option, + builder_proposal: bool, log: &Logger, - ) -> Result, BlockError> { - let block_contents: BlockContents = match Payload::block_type() { - BlockType::Full => { - let _get_timer = metrics::start_timer_vec( - &metrics::BLOCK_SERVICE_TIMES, - &[metrics::BEACON_BLOCK_HTTP_GET], - ); + ) -> Result, BlockError> { + let unsigned_block = if !builder_proposal { + let _get_timer = metrics::start_timer_vec( + &metrics::BLOCK_SERVICE_TIMES, + &[metrics::BEACON_BLOCK_HTTP_GET], + ); + UnsignedBlock::Full( beacon_node - .get_validator_blocks::(slot, randao_reveal_ref, graffiti.as_ref()) + .get_validator_blocks::(slot, randao_reveal_ref, graffiti.as_ref()) .await .map_err(|e| { BlockError::Recoverable(format!( @@ -620,19 +626,16 @@ impl BlockService { e )) })? - .data - } - BlockType::Blinded => { - let _get_timer = metrics::start_timer_vec( - &metrics::BLOCK_SERVICE_TIMES, - &[metrics::BLINDED_BEACON_BLOCK_HTTP_GET], - ); + .data, + ) + } else { + let _get_timer = metrics::start_timer_vec( + &metrics::BLOCK_SERVICE_TIMES, + &[metrics::BLINDED_BEACON_BLOCK_HTTP_GET], + ); + UnsignedBlock::Blinded( beacon_node - .get_validator_blinded_blocks::( - slot, - randao_reveal_ref, - graffiti.as_ref(), - ) + .get_validator_blinded_blocks::(slot, randao_reveal_ref, graffiti.as_ref()) .await .map_err(|e| { BlockError::Recoverable(format!( @@ -640,8 +643,8 @@ impl BlockService { e )) })? - .data - } + .data, + ) }; info!( @@ -649,13 +652,53 @@ impl BlockService { "Received unsigned block"; "slot" => slot.as_u64(), ); - if proposer_index != Some(block_contents.block().proposer_index()) { + if proposer_index != Some(unsigned_block.proposer_index()) { return Err(BlockError::Recoverable( "Proposer index does not match block proposer. Beacon chain re-orged".to_string(), )); } - Ok::<_, BlockError>(block_contents) + Ok::<_, BlockError>(unsigned_block) + } +} + +pub enum UnsignedBlock { + Full(BlockContents), + Blinded(BlindedBeaconBlock), +} + +impl UnsignedBlock { + pub fn proposer_index(&self) -> u64 { + match self { + UnsignedBlock::Full(block) => block.block().proposer_index(), + UnsignedBlock::Blinded(block) => block.proposer_index(), + } + } +} + +pub enum SignedBlock { + Full(SignedBlockContents), + Blinded(SignedBlindedBeaconBlock), +} + +impl SignedBlock { + pub fn slot(&self) -> Slot { + match self { + SignedBlock::Full(block) => block.signed_block().message().slot(), + SignedBlock::Blinded(block) => block.message().slot(), + } + } + pub fn num_deposits(&self) -> usize { + match self { + SignedBlock::Full(block) => block.signed_block().message().body().deposits().len(), + SignedBlock::Blinded(block) => block.message().body().deposits().len(), + } + } + pub fn num_attestations(&self) -> usize { + match self { + SignedBlock::Full(block) => block.signed_block().message().body().attestations().len(), + SignedBlock::Blinded(block) => block.message().body().attestations().len(), + } } } From 20c45f21461f9d87d6484357f0a372e133ecf837 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Sun, 12 Nov 2023 10:23:39 -0500 Subject: [PATCH 2/9] remove unnecessary ssz decode --- common/eth2/src/types.rs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/common/eth2/src/types.rs b/common/eth2/src/types.rs index b89411ba3a1..26b68ff986e 100644 --- a/common/eth2/src/types.rs +++ b/common/eth2/src/types.rs @@ -1508,13 +1508,6 @@ pub enum BlockContentsWrapper { Blinded(BlindedBeaconBlock), } -impl BlockContentsWrapper { - /// SSZ decode with fork variant determined by slot. - pub fn from_ssz_bytes(bytes: &[u8], spec: &ChainSpec) -> Result { - todo!() - } -} - /// A wrapper over a [`BeaconBlock`] or a [`BeaconBlockAndBlobSidecars`]. #[derive(Debug, Encode, Serialize, Deserialize)] #[serde(untagged)] From 555dc3070d2aec5faf7c62f1338952a81c17ce13 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Wed, 15 Nov 2023 09:36:35 -0500 Subject: [PATCH 3/9] add back build_sidecar --- beacon_node/beacon_chain/src/beacon_chain.rs | 8 +-- .../beacon_chain/src/blob_verification.rs | 2 +- .../beacon_chain/src/block_verification.rs | 55 ++++++------------- .../src/block_verification_types.rs | 7 +-- .../overflow_lru_cache.rs | 14 +---- beacon_node/beacon_chain/src/test_utils.rs | 24 ++++---- beacon_node/builder_client/src/lib.rs | 4 +- .../http_api/src/build_block_contents.rs | 3 +- beacon_node/http_api/src/lib.rs | 9 ++- beacon_node/http_api/src/produce_block.rs | 3 +- beacon_node/http_api/src/publish_blocks.rs | 16 ++++-- common/eth2/src/types.rs | 55 ++++--------------- consensus/types/src/blob_sidecar.rs | 53 ++++++++++++++++++ consensus/types/src/builder_bid.rs | 2 +- 14 files changed, 117 insertions(+), 138 deletions(-) diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index 782943aa41b..3357308e289 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -5197,17 +5197,13 @@ impl BeaconChain { .kzg .as_ref() .ok_or(BlockProductionError::TrustedSetupNotInitialized)?; - if !kzg_utils::validate_blobs::( + kzg_utils::validate_blobs::( kzg, expected_kzg_commitments, blobs.iter().collect(), &kzg_proofs, ) - .map_err(BlockProductionError::KzgError)? - { - //TODO(sean) fix - return Err(BlockProductionError::KzgError(todo!())); - } + .map_err(BlockProductionError::KzgError)?; Some((kzg_proofs.into(), blobs)) } diff --git a/beacon_node/beacon_chain/src/blob_verification.rs b/beacon_node/beacon_chain/src/blob_verification.rs index f76c703a353..8c5f7786994 100644 --- a/beacon_node/beacon_chain/src/blob_verification.rs +++ b/beacon_node/beacon_chain/src/blob_verification.rs @@ -184,7 +184,7 @@ impl GossipVerifiedBlob { /// This should ONLY be used for testing. pub fn __assumed_valid(blob: Arc>) -> Self { Self { - blob: KzgVerifiedBlob { blob: blob }, + blob: KzgVerifiedBlob { blob }, } } pub fn id(&self) -> BlobIdentifier { diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs index ada04dcf645..874c6aadb55 100644 --- a/beacon_node/beacon_chain/src/block_verification.rs +++ b/beacon_node/beacon_chain/src/block_verification.rs @@ -99,9 +99,9 @@ use store::{Error as DBError, HotStateSummary, KeyValueStore, StoreOp}; use task_executor::JoinHandle; use tree_hash::TreeHash; use types::{ - BeaconBlockRef, BeaconState, BeaconStateError, BlobSidecarList, ChainSpec, CloneConfig, Epoch, - EthSpec, ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes, - RelativeEpoch, SignedBeaconBlock, SignedBeaconBlockHeader, Slot, + BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, CloneConfig, Epoch, EthSpec, + ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch, + SignedBeaconBlock, SignedBeaconBlockHeader, Slot, }; use types::{BlobSidecar, ExecPayload}; @@ -669,7 +669,6 @@ pub trait IntoGossipVerifiedBlockContents: Sized { chain: &BeaconChain, ) -> Result, BlockContentsError>; fn inner_block(&self) -> &SignedBeaconBlock; - fn inner_blobs(&self) -> Option>; } impl IntoGossipVerifiedBlockContents for GossipVerifiedBlockContents { @@ -682,16 +681,6 @@ impl IntoGossipVerifiedBlockContents for GossipVerifiedB fn inner_block(&self) -> &SignedBeaconBlock { self.0.block.as_block() } - fn inner_blobs(&self) -> Option> { - self.1.as_ref().map(|blobs| { - VariableList::from( - blobs - .into_iter() - .map(GossipVerifiedBlob::cloned) - .collect::>(), - ) - }) - } } impl IntoGossipVerifiedBlockContents for SignedBlockContents { @@ -699,29 +688,21 @@ impl IntoGossipVerifiedBlockContents for SignedBlockCont self, chain: &BeaconChain, ) -> Result, BlockContentsError> { - let (block, blob_items) = self.deconstruct(); + let (block, blobs) = self.deconstruct(); - let gossip_verified_blobs = blob_items + let gossip_verified_blobs = blobs .map(|(kzg_proofs, blobs)| { - let expected_kzg_commitments = - block.message().body().blob_kzg_commitments().map_err(|e| { - BlockContentsError::BlockError(BlockError::BeaconChainError( - BeaconChainError::BeaconStateError(e), - )) - })?; - let sidecars = BlobSidecar::build_sidecar( - blobs, - &block, - expected_kzg_commitments, - kzg_proofs.into(), - ) - .map_err(BlockContentsError::SidecarError)?; - Ok::<_, BlockContentsError>(VariableList::from( - sidecars - .into_iter() - .map(|blob| GossipVerifiedBlob::new(blob, chain)) - .collect::, _>>()?, - )) + let signed_block_header = block.signed_block_header(); + let mut gossip_verified_blobs = vec![]; + for (i, (kzg_proof, blob)) in kzg_proofs.iter().zip(blobs).enumerate() { + let blob = + BlobSidecar::new(i, blob, signed_block_header.clone(), &block, *kzg_proof) + .map_err(BlockContentsError::SidecarError)?; + let gossip_verified_blob = GossipVerifiedBlob::new(Arc::new(blob), chain)?; + gossip_verified_blobs.push(gossip_verified_blob); + } + let gossip_verified_blobs = VariableList::from(gossip_verified_blobs); + Ok::<_, BlockContentsError>(VariableList::from(gossip_verified_blobs)) }) .transpose()?; let gossip_verified_block = GossipVerifiedBlock::new(Arc::new(block), chain)?; @@ -732,10 +713,6 @@ impl IntoGossipVerifiedBlockContents for SignedBlockCont fn inner_block(&self) -> &SignedBeaconBlock { self.signed_block() } - - fn inner_blobs(&self) -> Option> { - self.blobs_sidecar_list() - } } /// Implemented on types that can be converted into a `ExecutionPendingBlock`. diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs index df86b4f2faf..3c97da7e882 100644 --- a/beacon_node/beacon_chain/src/block_verification_types.rs +++ b/beacon_node/beacon_chain/src/block_verification_types.rs @@ -8,7 +8,7 @@ use derivative::Derivative; use ssz_types::VariableList; use state_processing::ConsensusContext; use std::sync::Arc; -use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList}; +use types::blob_sidecar::{BlobIdentifier, BlobSidecarError, FixedBlobSidecarList}; use types::{ BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256, SignedBeaconBlock, SignedBeaconBlockHeader, Slot, @@ -295,8 +295,7 @@ pub type GossipVerifiedBlockContents = pub enum BlockContentsError { BlockError(BlockError), BlobError(GossipBlobError), - // TODO(pawan): absorb into one of the above types - SidecarError(String), + SidecarError(BlobSidecarError), } impl From> for BlockContentsError { @@ -321,7 +320,7 @@ impl std::fmt::Display for BlockContentsError { write!(f, "BlobError({})", err) } BlockContentsError::SidecarError(err) => { - write!(f, "SidecarError({})", err) + write!(f, "SidecarError({:?})", err) } } } diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs index 980714b8970..3b3875384bd 100644 --- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs +++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs @@ -753,7 +753,7 @@ mod test { use std::ops::AddAssign; use store::{HotColdDB, ItemStore, LevelDB, StoreConfig}; use tempfile::{tempdir, TempDir}; - use types::{ChainSpec, ExecPayload, MinimalEthSpec, Sidecar}; + use types::{ChainSpec, ExecPayload, MinimalEthSpec}; const LOW_VALIDATOR_COUNT: usize = 32; @@ -919,17 +919,7 @@ mod test { info!(log, "done printing kzg commitments"); let gossip_verified_blobs = if let Some((kzg_proofs, blobs)) = maybe_blobs { - let sidecars = BlobSidecar::build_sidecar( - blobs, - &block, - block - .message() - .body() - .blob_kzg_commitments() - .expect("should be deneb fork"), - kzg_proofs.into(), - ) - .unwrap(); + let sidecars = BlobSidecar::build_sidecars(blobs, &block, kzg_proofs.into()).unwrap(); Vec::from(sidecars) .into_iter() .map(|sidecar| { diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs index 43169055eff..7b32018d8d6 100644 --- a/beacon_node/beacon_chain/src/test_utils.rs +++ b/beacon_node/beacon_chain/src/test_utils.rs @@ -1826,14 +1826,12 @@ where block_contents: SignedBlockContentsTuple, ) -> Result> { self.set_current_slot(slot); - let (block, blobs) = block_contents; + let (block, blob_items) = block_contents; - let sidecars = if let Some(blob_items) = blobs { - let expected_kzg_commitments = block.message().body().blob_kzg_commitments().unwrap(); - todo!() - } else { - None - }; + let sidecars = blob_items + .map(|(proofs, blobs)| BlobSidecar::build_sidecars(blobs, &block, proofs)) + .transpose() + .unwrap(); let block_hash: SignedBeaconBlockHash = self .chain .process_block( @@ -1853,14 +1851,12 @@ where &self, block_contents: SignedBlockContentsTuple, ) -> Result> { - let (block, blobs) = block_contents; + let (block, blob_items) = block_contents; - let sidecars = if let Some(blob_items) = blobs { - let expected_kzg_commitments = block.message().body().blob_kzg_commitments().unwrap(); - todo!() - } else { - None - }; + let sidecars = blob_items + .map(|(proofs, blobs)| BlobSidecar::build_sidecars(blobs, &block, proofs)) + .transpose() + .unwrap(); let block_root = block.canonical_root(); let block_hash: SignedBeaconBlockHash = self .chain diff --git a/beacon_node/builder_client/src/lib.rs b/beacon_node/builder_client/src/lib.rs index 22e909041fc..934ef059d5b 100644 --- a/beacon_node/builder_client/src/lib.rs +++ b/beacon_node/builder_client/src/lib.rs @@ -1,7 +1,7 @@ use eth2::types::builder_bid::SignedBuilderBid; use eth2::types::{ - BlindedPayload, EthSpec, ExecutionBlockHash, ForkVersionedResponse, PublicKeyBytes, - SignedBlockContents, SignedValidatorRegistrationData, Slot, + EthSpec, ExecutionBlockHash, ForkVersionedResponse, PublicKeyBytes, + SignedValidatorRegistrationData, Slot, }; use eth2::types::{FullPayloadContents, SignedBlindedBeaconBlock}; pub use eth2::Error; diff --git a/beacon_node/http_api/src/build_block_contents.rs b/beacon_node/http_api/src/build_block_contents.rs index 29bafc5ff1b..b7c899c0e7b 100644 --- a/beacon_node/http_api/src/build_block_contents.rs +++ b/beacon_node/http_api/src/build_block_contents.rs @@ -1,7 +1,6 @@ use beacon_chain::{BeaconBlockResponse, BeaconBlockResponseType, BlockProductionError}; use eth2::types::{BeaconBlockAndBlobSidecars, BlockContents, BlockContentsWrapper}; -use serde::{Deserialize, Serialize}; -use types::{BlindedBeaconBlock, EthSpec, ForkName}; +use types::{EthSpec, ForkName}; type Error = warp::reject::Rejection; pub fn build_block_contents( diff --git a/beacon_node/http_api/src/lib.rs b/beacon_node/http_api/src/lib.rs index 83a029828e4..04178f5c32c 100644 --- a/beacon_node/http_api/src/lib.rs +++ b/beacon_node/http_api/src/lib.rs @@ -76,11 +76,10 @@ use tokio_stream::{ }; use types::{ Attestation, AttestationData, AttestationShufflingId, AttesterSlashing, BeaconStateError, - BlindedPayload, CommitteeCache, ConfigAndPreset, Epoch, EthSpec, ForkName, - ProposerPreparationData, ProposerSlashing, RelativeEpoch, SignedAggregateAndProof, - SignedBlindedBeaconBlock, SignedBlsToExecutionChange, SignedContributionAndProof, - SignedValidatorRegistrationData, SignedVoluntaryExit, Slot, SyncCommitteeMessage, - SyncContributionData, + CommitteeCache, ConfigAndPreset, Epoch, EthSpec, ForkName, ProposerPreparationData, + ProposerSlashing, RelativeEpoch, SignedAggregateAndProof, SignedBlindedBeaconBlock, + SignedBlsToExecutionChange, SignedContributionAndProof, SignedValidatorRegistrationData, + SignedVoluntaryExit, Slot, SyncCommitteeMessage, SyncContributionData, }; use validator::pubkey_to_validator_index; use version::{ diff --git a/beacon_node/http_api/src/produce_block.rs b/beacon_node/http_api/src/produce_block.rs index af94d3e9915..eb4954a77af 100644 --- a/beacon_node/http_api/src/produce_block.rs +++ b/beacon_node/http_api/src/produce_block.rs @@ -3,8 +3,7 @@ use std::sync::Arc; use types::{payload::BlockProductionVersion, *}; use beacon_chain::{ - BeaconBlockResponse, BeaconBlockResponseType, BeaconChain, BeaconChainTypes, - ProduceBlockVerification, + BeaconBlockResponseType, BeaconChain, BeaconChainTypes, ProduceBlockVerification, }; use eth2::types::{self as api_types, EndpointVersion, SkipRandaoVerification}; use ssz::Encode; diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs index 595ffdbb15c..e780ac9556e 100644 --- a/beacon_node/http_api/src/publish_blocks.rs +++ b/beacon_node/http_api/src/publish_blocks.rs @@ -19,9 +19,9 @@ use std::time::Duration; use tokio::sync::mpsc::UnboundedSender; use tree_hash::TreeHash; use types::{ - AbstractExecPayload, BeaconBlockRef, BlindedPayload, BlobSidecarList, EthSpec, ExecPayload, - ExecutionBlockHash, ForkName, FullPayload, FullPayloadMerge, Hash256, SignedBeaconBlock, - SignedBlindedBeaconBlock, + AbstractExecPayload, BeaconBlockRef, BlobSidecarList, EthSpec, ExecPayload, ExecutionBlockHash, + ForkName, FullPayload, FullPayloadMerge, Hash256, SignedBeaconBlock, SignedBlindedBeaconBlock, + VariableList, }; use warp::http::StatusCode; use warp::{reply::Response, Rejection, Reply}; @@ -109,9 +109,6 @@ pub async fn publish_block>(); + VariableList::from(blobs) + }); let block_root = block_root.unwrap_or(gossip_verified_block.block_root); diff --git a/common/eth2/src/types.rs b/common/eth2/src/types.rs index 86693418710..7b9fab72f4b 100644 --- a/common/eth2/src/types.rs +++ b/common/eth2/src/types.rs @@ -12,8 +12,8 @@ use std::convert::TryFrom; use std::fmt::{self, Display}; use std::str::{from_utf8, FromStr}; use std::time::Duration; -use tree_hash::TreeHash; use types::beacon_block_body::KzgCommitments; +// use types::blob_sidecar::build_sidecars; pub use types::*; #[cfg(feature = "lighthouse")] @@ -1433,7 +1433,7 @@ mod tests { type E = MainnetEthSpec; let spec = ForkName::Capella.make_genesis_spec(E::default_spec()); - let block: SignedBlockContents> = SignedBeaconBlock::from_block( + let block: SignedBlockContents = SignedBeaconBlock::from_block( BeaconBlock::::Capella(BeaconBlockCapella::empty(&spec)), Signature::empty(), ) @@ -1459,7 +1459,7 @@ mod tests { let kzg_proofs = KzgProofs::::from(vec![KzgProof::empty()]); let signed_block_contents = SignedBlockContents::new(block, Some((kzg_proofs, blobs))); - let decoded: SignedBlockContents> = + let decoded: SignedBlockContents = SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) .expect("should decode BlockAndBlobSidecars"); assert!(matches!( @@ -1467,27 +1467,6 @@ mod tests { SignedBlockContents::BlockAndBlobSidecars(_) )); } - - #[test] - fn ssz_signed_blinded_block_contents_with_blobs() { - type E = MainnetEthSpec; - let mut spec = E::default_spec(); - spec.altair_fork_epoch = Some(Epoch::new(0)); - spec.bellatrix_fork_epoch = Some(Epoch::new(0)); - spec.capella_fork_epoch = Some(Epoch::new(0)); - spec.deneb_fork_epoch = Some(Epoch::new(0)); - - let blinded_block = SignedBeaconBlock::from_block( - BeaconBlock::>::Deneb(BeaconBlockDeneb::empty(&spec)), - Signature::empty(), - ); - let signed_block_contents = SignedBlockContents::new(blinded_block, None); - - let decoded: SignedBlockContents> = - SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) - .expect("should decode BlindedBlock"); - assert!(matches!(decoded, SignedBlockContents::Block(_))); - } } #[derive(Debug, Encode, Serialize, Deserialize)] @@ -1545,15 +1524,15 @@ impl BlockContents { ForkName::Deneb => { let mut builder = ssz::SszDecoderBuilder::new(bytes); - builder.register_anonymous_variable_length_item()?; - builder.register_type::>()?; - builder.register_type::>()?; + builder.register_anonymous_variable_length_item()?; + builder.register_type::>()?; + builder.register_type::>()?; - let mut decoder = builder.build()?; - let block = decoder - .decode_next_with(|bytes| BeaconBlock::from_ssz_bytes(bytes, spec))?; - let kzg_proofs = decoder.decode_next()?; - let blobs = decoder.decode_next()?; + let mut decoder = builder.build()?; + let block = + decoder.decode_next_with(|bytes| BeaconBlock::from_ssz_bytes(bytes, spec))?; + let kzg_proofs = decoder.decode_next()?; + let blobs = decoder.decode_next()?; Ok(BlockContents::new(block, Some((kzg_proofs, blobs)))) } @@ -1691,18 +1670,6 @@ impl SignedBlockContents { } } - pub fn blobs_sidecar_list(&self) -> Option> { - match self { - SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => { - let blobs = block_and_sidecars.blobs.clone(); - let block = &block_and_sidecars.signed_block; - let kzg_commitments = block.message().body().blob_kzg_commitments().ok()?; - todo!() - } - SignedBlockContents::Block(_block) => None, - } - } - pub fn deconstruct(self) -> SignedBlockContentsTuple { match self { SignedBlockContents::BlockAndBlobSidecars(block_and_sidecars) => ( diff --git a/consensus/types/src/blob_sidecar.rs b/consensus/types/src/blob_sidecar.rs index 6b5d5fb2c93..22eb5e1bfd4 100644 --- a/consensus/types/src/blob_sidecar.rs +++ b/consensus/types/src/blob_sidecar.rs @@ -3,6 +3,7 @@ use crate::{ beacon_block_body::BLOB_KZG_COMMITMENTS_INDEX, BeaconBlockHeader, Blob, EthSpec, Hash256, SignedBeaconBlockHeader, Slot, }; +use crate::{KzgProofs, SignedBeaconBlock}; use bls::Signature; use derivative::Derivative; use kzg::{ @@ -94,7 +95,44 @@ impl Ord for BlobSidecar { } } +#[derive(Debug)] +pub enum BlobSidecarError { + PreDeneb, + MissingKzgCommitment, +} + impl BlobSidecar { + pub fn new( + index: usize, + blob: Blob, + signed_block_header: SignedBeaconBlockHeader, + signed_block: &SignedBeaconBlock, + kzg_proof: KzgProof, + ) -> Result { + let expected_kzg_commitments = signed_block + .message() + .body() + .blob_kzg_commitments() + .map_err(|_e| BlobSidecarError::PreDeneb)?; + let kzg_commitment = *expected_kzg_commitments + .get(index) + .ok_or(BlobSidecarError::MissingKzgCommitment)?; + let kzg_commitment_inclusion_proof = signed_block + .message() + .body() + .kzg_commitment_merkle_proof(index) + .ok_or(BlobSidecarError::PreDeneb)?; + + Ok(Self { + index: index as u64, + blob, + kzg_commitment, + kzg_proof, + signed_block_header, + kzg_commitment_inclusion_proof, + }) + } + pub fn id(&self) -> BlobIdentifier { BlobIdentifier { block_root: self.block_root(), @@ -207,6 +245,21 @@ impl BlobSidecar { // Fixed part Self::empty().as_ssz_bytes().len() } + + pub fn build_sidecars( + blobs: BlobsList, + block: &SignedBeaconBlock, + kzg_proofs: KzgProofs, + ) -> Result, BlobSidecarError> { + let signed_block_header = block.signed_block_header(); + let mut blob_sidecars = vec![]; + for (i, (kzg_proof, blob)) in kzg_proofs.iter().zip(blobs).enumerate() { + let blob_sidecar = + BlobSidecar::new(i, blob, signed_block_header.clone(), &block, *kzg_proof)?; + blob_sidecars.push(Arc::new(blob_sidecar)); + } + Ok(VariableList::from(blob_sidecars)) + } } pub type SidecarList = VariableList, ::MaxBlobsPerBlock>; diff --git a/consensus/types/src/builder_bid.rs b/consensus/types/src/builder_bid.rs index bf9d1fbe8ad..f43585000a5 100644 --- a/consensus/types/src/builder_bid.rs +++ b/consensus/types/src/builder_bid.rs @@ -2,7 +2,7 @@ use crate::beacon_block_body::KzgCommitments; use crate::{ ChainSpec, EthSpec, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderMerge, ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, ForkName, - ForkVersionDeserialize, KzgProofs, SignedRoot, Uint256, + ForkVersionDeserialize, SignedRoot, Uint256, }; use bls::PublicKeyBytes; use bls::Signature; From 825ae62fd67328cf5d978669d76bdd81774d96fd Mon Sep 17 00:00:00 2001 From: realbigsean Date: Thu, 16 Nov 2023 05:02:01 -0500 Subject: [PATCH 4/9] remove default at fork for blobs --- beacon_node/execution_layer/src/lib.rs | 19 ----------------- consensus/types/src/payload.rs | 29 ++++++++------------------ 2 files changed, 9 insertions(+), 39 deletions(-) diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs index 7c076af0db9..6e12e2bc730 100644 --- a/beacon_node/execution_layer/src/lib.rs +++ b/beacon_node/execution_layer/src/lib.rs @@ -273,25 +273,6 @@ impl> BlockProposalContents block_value, } } - pub fn default_at_fork(fork_name: ForkName) -> Result { - Ok(match fork_name { - ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => { - BlockProposalContents::Payload { - payload: Payload::default_at_fork(fork_name)?, - block_value: Uint256::zero(), - } - } - ForkName::Deneb => BlockProposalContents::PayloadAndBlobs { - payload: Payload::default_at_fork(fork_name)?, - block_value: Uint256::zero(), - kzg_commitments: VariableList::default(), - //TODO(sean) fix - // blobs: Some(Payload::default_blobs_at_fork(fork_name)?), - blobs: None, - proofs: Some(VariableList::default()), - }, - }) - } } #[derive(Clone, PartialEq)] diff --git a/consensus/types/src/payload.rs b/consensus/types/src/payload.rs index c19a98db336..fa7745ad977 100644 --- a/consensus/types/src/payload.rs +++ b/consensus/types/src/payload.rs @@ -101,8 +101,6 @@ pub trait AbstractExecPayload: + Into + for<'a> From>> + TryFrom>; - - fn default_at_fork(fork_name: ForkName) -> Result; } #[superstruct( @@ -275,6 +273,15 @@ impl FullPayload { cons(inner.execution_payload) }) } + + pub fn default_at_fork(fork_name: ForkName) -> Result { + match fork_name { + ForkName::Base | ForkName::Altair => Err(Error::IncorrectStateVariant), + ForkName::Merge => Ok(FullPayloadMerge::default().into()), + ForkName::Capella => Ok(FullPayloadCapella::default().into()), + ForkName::Deneb => Ok(FullPayloadDeneb::default().into()), + } + } } impl<'a, T: EthSpec> FullPayloadRef<'a, T> { @@ -383,15 +390,6 @@ impl AbstractExecPayload for FullPayload { type Merge = FullPayloadMerge; type Capella = FullPayloadCapella; type Deneb = FullPayloadDeneb; - - fn default_at_fork(fork_name: ForkName) -> Result { - match fork_name { - ForkName::Base | ForkName::Altair => Err(Error::IncorrectStateVariant), - ForkName::Merge => Ok(FullPayloadMerge::default().into()), - ForkName::Capella => Ok(FullPayloadCapella::default().into()), - ForkName::Deneb => Ok(FullPayloadDeneb::default().into()), - } - } } impl From> for FullPayload { @@ -896,15 +894,6 @@ impl AbstractExecPayload for BlindedPayload { type Merge = BlindedPayloadMerge; type Capella = BlindedPayloadCapella; type Deneb = BlindedPayloadDeneb; - - fn default_at_fork(fork_name: ForkName) -> Result { - match fork_name { - ForkName::Base | ForkName::Altair => Err(Error::IncorrectStateVariant), - ForkName::Merge => Ok(BlindedPayloadMerge::default().into()), - ForkName::Capella => Ok(BlindedPayloadCapella::default().into()), - ForkName::Deneb => Ok(BlindedPayloadDeneb::default().into()), - } - } } impl From> for BlindedPayload { From 8ee1ff98e9aef0449ad4c8d1d995ca42ae838ca0 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Thu, 16 Nov 2023 05:53:27 -0500 Subject: [PATCH 5/9] fix beacon chain tests --- .../src/observed_blob_sidecars.rs | 63 ++++++++++++------- .../beacon_chain/tests/block_verification.rs | 14 +---- 2 files changed, 43 insertions(+), 34 deletions(-) diff --git a/beacon_node/beacon_chain/src/observed_blob_sidecars.rs b/beacon_node/beacon_chain/src/observed_blob_sidecars.rs index cd14ebfdcd3..8a4fc5ab653 100644 --- a/beacon_node/beacon_chain/src/observed_blob_sidecars.rs +++ b/beacon_node/beacon_chain/src/observed_blob_sidecars.rs @@ -101,17 +101,41 @@ impl ObservedBlobSidecars { mod tests { use super::*; use std::sync::Arc; - use types::{BlobSidecar, Hash256, MainnetEthSpec}; + use tree_hash::TreeHash; + use types::{ + test_utils::TestRandom, BlobSidecar, Hash256, MainnetEthSpec, SignedBeaconBlockHeader, + }; type E = MainnetEthSpec; - fn get_blob_sidecar(slot: u64, block_root: Hash256, index: u64) -> Arc> { + fn get_blob_sidecar(slot: u64, index: u64) -> (Hash256, Arc>) { + let mut header = SignedBeaconBlockHeader::random_for_test(&mut rand::thread_rng()); + header.message.slot = slot.into(); + let block_root = header.message.tree_hash_root(); + let mut blob_sidecar = BlobSidecar::empty(); - // TODO(pawan): have a block root setter for tests - // blob_sidecar.block_root = block_root; - blob_sidecar.signed_block_header.message.slot = slot.into(); + blob_sidecar.signed_block_header = header; blob_sidecar.index = index; - Arc::new(blob_sidecar) + (block_root, Arc::new(blob_sidecar)) + } + + fn get_blob_sidecars( + slot: u64, + start_index: u64, + count: u64, + ) -> (Hash256, Vec>>) { + let mut sidecars = vec![]; + let mut header = SignedBeaconBlockHeader::random_for_test(&mut rand::thread_rng()); + header.message.slot = slot.into(); + let block_root = header.message.tree_hash_root(); + + let mut blob_sidecar = BlobSidecar::empty(); + blob_sidecar.signed_block_header = header; + for i in start_index..start_index + count { + blob_sidecar.index = i; + sidecars.push(Arc::new(blob_sidecar.clone())); + } + (block_root, sidecars) } #[test] @@ -122,8 +146,7 @@ mod tests { assert_eq!(cache.items.len(), 0, "no slots should be present"); // Slot 0, index 0 - let block_root_a = Hash256::random(); - let sidecar_a = get_blob_sidecar(0, block_root_a, 0); + let (block_root_a, sidecar_a) = get_blob_sidecar(0, 0); assert_eq!( cache.observe_sidecar(&sidecar_a), @@ -186,7 +209,7 @@ mod tests { */ // First slot of finalized epoch - let block_b = get_blob_sidecar(E::slots_per_epoch(), Hash256::random(), 0); + let (_, block_b) = get_blob_sidecar(E::slots_per_epoch(), 0); assert_eq!( cache.observe_sidecar(&block_b), @@ -206,8 +229,7 @@ mod tests { let three_epochs = E::slots_per_epoch() * 3; // First slot of finalized epoch - let block_root_b = Hash256::random(); - let block_b = get_blob_sidecar(three_epochs, block_root_b, 0); + let (block_root_b, block_b) = get_blob_sidecar(three_epochs, 0); assert_eq!( cache.observe_sidecar(&block_b), @@ -255,9 +277,14 @@ mod tests { fn simple_observations() { let mut cache = ObservedBlobSidecars::default(); + let invalid_index = E::max_blobs_per_block() as u64; + let (block_root_a, sidecars) = get_blob_sidecars(0, 0, invalid_index + 1); // Slot 0, index 0 - let block_root_a = Hash256::random(); - let sidecar_a = get_blob_sidecar(0, block_root_a, 0); + let sidecar_a = sidecars[0].clone(); + // Slot 0, index 1 + let sidecar_c = sidecars[1].clone(); + // Slot 0, index 6 (invalid) + let sidecar_d = sidecars[6].clone(); assert_eq!( cache.is_known(&sidecar_a), @@ -296,9 +323,7 @@ mod tests { ); // Slot 1, proposer 0 - - let block_root_b = Hash256::random(); - let sidecar_b = get_blob_sidecar(1, block_root_b, 0); + let (block_root_b, sidecar_b) = get_blob_sidecar(1, 0); assert_eq!( cache.is_known(&sidecar_b), @@ -342,9 +367,6 @@ mod tests { "only one proposer should be present in slot 1" ); - // Slot 0, index 1 - let sidecar_c = get_blob_sidecar(0, block_root_a, 1); - assert_eq!( cache.is_known(&sidecar_c), Ok(false), @@ -378,9 +400,6 @@ mod tests { "two blob indices should be present in slot 0" ); - // Try adding an out of bounds index - let invalid_index = E::max_blobs_per_block() as u64; - let sidecar_d = get_blob_sidecar(0, block_root_a, invalid_index); assert_eq!( cache.observe_sidecar(&sidecar_d), Err(Error::InvalidBlobIndex(invalid_index)), diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs index f256bcdd5cb..174a4bf6212 100644 --- a/beacon_node/beacon_chain/tests/block_verification.rs +++ b/beacon_node/beacon_chain/tests/block_verification.rs @@ -1154,18 +1154,8 @@ async fn verify_block_for_gossip_slashing_detection() { .unwrap(); if let Some((kzg_proofs, blobs)) = blobs1 { - let sidecars = BlobSidecar::build_sidecar( - blobs, - verified_block.block(), - verified_block - .block() - .message() - .body() - .blob_kzg_commitments() - .unwrap(), - kzg_proofs.into(), - ) - .unwrap(); + let sidecars = + BlobSidecar::build_sidecars(blobs, verified_block.block(), kzg_proofs).unwrap(); for sidecar in sidecars { let blob_index = sidecar.index; let verified_blob = harness From 9fe8b35123d5f1db0063831f4b3ed09bcd4b5bb6 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Fri, 17 Nov 2023 04:08:50 -0500 Subject: [PATCH 6/9] get relase tests compiling --- .../tests/broadcast_validation_tests.rs | 74 ++----- .../http_api/tests/interactive_tests.rs | 6 +- beacon_node/http_api/tests/tests.rs | 199 ++++++++---------- common/eth2/src/lib.rs | 8 +- 4 files changed, 115 insertions(+), 172 deletions(-) diff --git a/beacon_node/http_api/tests/broadcast_validation_tests.rs b/beacon_node/http_api/tests/broadcast_validation_tests.rs index 6604941340d..c1c7a00a523 100644 --- a/beacon_node/http_api/tests/broadcast_validation_tests.rs +++ b/beacon_node/http_api/tests/broadcast_validation_tests.rs @@ -2,15 +2,12 @@ use beacon_chain::{ test_utils::{AttestationStrategy, BlockStrategy}, GossipVerifiedBlock, IntoGossipVerifiedBlockContents, }; -use eth2::types::{ - BroadcastValidation, SignedBeaconBlock, SignedBlindedBeaconBlock, SignedBlockContents, - SignedBlockContentsTuple, -}; +use eth2::types::{BroadcastValidation, SignedBeaconBlock, SignedBlockContents}; use http_api::test_utils::InteractiveTester; use http_api::{publish_blinded_block, publish_block, reconstruct_block, ProvenancedBlock}; use std::sync::Arc; use tree_hash::TreeHash; -use types::{BlindedPayload, FullPayload, Hash256, MainnetEthSpec, Slot}; +use types::{Hash256, MainnetEthSpec, Slot}; use warp::Rejection; use warp_utils::reject::CustomBadRequest; @@ -355,10 +352,8 @@ pub async fn consensus_partial_pass_only_consensus() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let ((block_a, _), state_after_a): ((SignedBeaconBlock, _), _) = - tester.harness.make_block(state_a.clone(), slot_b).await; - let ((block_b, blobs_b), state_after_b): ((SignedBeaconBlock, _), _) = - tester.harness.make_block(state_a, slot_b).await; + let ((block_a, _), state_after_a) = tester.harness.make_block(state_a.clone(), slot_b).await; + let ((block_b, blobs_b), state_after_b) = tester.harness.make_block(state_a, slot_b).await; let block_b_root = block_b.canonical_root(); /* check for `make_block` curios */ @@ -773,11 +768,9 @@ pub async fn blinded_gossip_invalid() { }) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -826,11 +819,9 @@ pub async fn blinded_gossip_partial_pass() { }) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -877,7 +868,7 @@ pub async fn blinded_gossip_full_pass() { assert!(tester .harness .chain - .block_is_known_to_fork_choice(&block_contents.signed_block().canonical_root())); + .block_is_known_to_fork_choice(&blinded_block.canonical_root())); } // This test checks that a block that is valid from both a gossip and consensus perspective is accepted when using `broadcast_validation=gossip`. @@ -919,7 +910,7 @@ pub async fn blinded_gossip_full_pass_ssz() { assert!(tester .harness .chain - .block_is_known_to_fork_choice(&block_contents.signed_block().canonical_root())); + .block_is_known_to_fork_choice(&blinded_block.canonical_root())); } /// This test checks that a block that is **invalid** from a gossip perspective gets rejected when using `broadcast_validation=consensus`. @@ -958,11 +949,9 @@ pub async fn blinded_consensus_invalid() { }) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -1009,11 +998,9 @@ pub async fn blinded_consensus_gossip() { .make_block_with_modifier(state_a, slot_b, |b| *b.state_root_mut() = Hash256::zero()) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -1066,7 +1053,7 @@ pub async fn blinded_consensus_full_pass() { assert!(tester .harness .chain - .block_is_known_to_fork_choice(&blinded_block.signed_block().canonical_root())); + .block_is_known_to_fork_choice(&blinded_block.canonical_root())); } /// This test checks that a block that is **invalid** from a gossip perspective gets rejected when using `broadcast_validation=consensus_and_equivocation`. @@ -1106,11 +1093,9 @@ pub async fn blinded_equivocation_invalid() { }) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -1167,7 +1152,7 @@ pub async fn blinded_equivocation_consensus_early_equivocation() { /* submit `block_a` as valid */ assert!(tester .client - .post_beacon_blinded_blocks_v2(&block_contents_a, validation_level) + .post_beacon_blinded_blocks_v2(&block_a, validation_level) .await .is_ok()); assert!(tester @@ -1178,7 +1163,7 @@ pub async fn blinded_equivocation_consensus_early_equivocation() { /* submit `block_b` which should induce equivocation */ let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&block_contents_b, validation_level) + .post_beacon_blinded_blocks_v2(&block_b, validation_level) .await; assert!(response.is_err()); @@ -1225,11 +1210,9 @@ pub async fn blinded_equivocation_gossip() { .make_block_with_modifier(state_a, slot_b, |b| *b.state_root_mut() = Hash256::zero()) .await; - let blinded_block_contents = into_signed_blinded_block_contents(block_contents_tuple); - let response: Result<(), eth2::Error> = tester .client - .post_beacon_blinded_blocks_v2(&blinded_block_contents, validation_level) + .post_beacon_blinded_blocks_v2(&block_contents_tuple.0.clone_as_blinded(), validation_level) .await; assert!(response.is_err()); @@ -1275,12 +1258,11 @@ pub async fn blinded_equivocation_consensus_late_equivocation() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let ((block_a, blobs_a), state_after_a): ((SignedBlindedBeaconBlock, _), _) = tester + let (block_a, state_after_a) = tester .harness .make_blinded_block(state_a.clone(), slot_b) .await; - let ((block_b, blobs_b), state_after_b): ((SignedBlindedBeaconBlock, _), _) = - tester.harness.make_blinded_block(state_a, slot_b).await; + let (block_b, state_after_b) = tester.harness.make_blinded_block(state_a, slot_b).await; /* check for `make_blinded_block` curios */ assert_eq!(block_a.state_root(), state_after_a.tree_hash_root()); @@ -1290,7 +1272,7 @@ pub async fn blinded_equivocation_consensus_late_equivocation() { let unblinded_block_a = reconstruct_block( tester.harness.chain.clone(), block_a.canonical_root(), - SignedBlockContents::new(block_a, blobs_a), + block_a, test_logger.clone(), ) .await @@ -1298,7 +1280,7 @@ pub async fn blinded_equivocation_consensus_late_equivocation() { let unblinded_block_b = reconstruct_block( tester.harness.chain.clone(), block_b.canonical_root(), - SignedBlockContents::new(block_b.clone(), blobs_b.clone()), + block_b.clone(), test_logger.clone(), ) .await @@ -1327,7 +1309,7 @@ pub async fn blinded_equivocation_consensus_late_equivocation() { let channel = tokio::sync::mpsc::unbounded_channel(); let publication_result = publish_blinded_block( - SignedBlockContents::new(block_b, blobs_b), + block_b, tester.harness.chain, &channel.0, test_logger, @@ -1372,15 +1354,11 @@ pub async fn blinded_equivocation_full_pass() { let slot_b = slot_a + 1; let state_a = tester.harness.get_current_state(); - let ((block, blobs), _): ((SignedBlindedBeaconBlock, _), _) = - tester.harness.make_blinded_block(state_a, slot_b).await; + let (block, _) = tester.harness.make_blinded_block(state_a, slot_b).await; let response: Result<(), eth2::Error> = tester .client - .post_beacon_blocks_v2( - &SignedBlockContents::new(block.clone(), blobs), - validation_level, - ) + .post_beacon_blinded_blocks_v2(&block, validation_level) .await; assert!(response.is_ok()); @@ -1389,11 +1367,3 @@ pub async fn blinded_equivocation_full_pass() { .chain .block_is_known_to_fork_choice(&block.canonical_root())); } - -fn into_signed_blinded_block_contents( - block_contents_tuple: SignedBlockContentsTuple>, -) -> SignedBlockContents> { - let (block, blob_items) = block_contents_tuple; - // TODO(pawan): recheck if we want to keep the BlobsRootList for the blinded variant - SignedBlockContents::new(block.into(), None) -} diff --git a/beacon_node/http_api/tests/interactive_tests.rs b/beacon_node/http_api/tests/interactive_tests.rs index 6f1586bc87d..48a2f450e21 100644 --- a/beacon_node/http_api/tests/interactive_tests.rs +++ b/beacon_node/http_api/tests/interactive_tests.rs @@ -17,8 +17,8 @@ use std::sync::Arc; use std::time::Duration; use tree_hash::TreeHash; use types::{ - Address, Epoch, EthSpec, ExecPayload, ExecutionBlockHash, ForkName, FullPayload, - MainnetEthSpec, MinimalEthSpec, ProposerPreparationData, Slot, + Address, Epoch, EthSpec, ExecPayload, ExecutionBlockHash, ForkName, MainnetEthSpec, + MinimalEthSpec, ProposerPreparationData, Slot, }; use eth2::types::ForkVersionedBeaconBlockType::{Blinded, Full}; @@ -824,7 +824,7 @@ pub async fn fork_choice_before_proposal() { .into(); let block_d = tester .client - .get_validator_blocks::>(slot_d, &randao_reveal, None) + .get_validator_blocks::(slot_d, &randao_reveal, None) .await .unwrap() .data diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index 47c84665e80..8d0ee92a411 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -1356,7 +1356,7 @@ impl ApiTester { .is_ok()); // Blinded deneb block contents is just the blinded block - let blinded_block_contents = block_contents.clone_as_blinded(); + let blinded_block_contents = block_contents.signed_block().clone_as_blinded(); // Test all the POST methods in sequence, they should all behave the same. let responses = vec![ @@ -2513,7 +2513,7 @@ impl ApiTester { let block = self .client - .get_validator_blocks::>(slot, &randao_reveal, None) + .get_validator_blocks::(slot, &randao_reveal, None) .await .unwrap() .data @@ -2577,14 +2577,13 @@ impl ApiTester { let block_bytes = self .client - .get_validator_blocks_ssz::>(slot, &randao_reveal, None) + .get_validator_blocks_ssz::(slot, &randao_reveal, None) .await .unwrap() .expect("block bytes"); - let block_contents = - BlockContents::>::from_ssz_bytes(&block_bytes, &self.chain.spec) - .expect("block contents bytes can be decoded"); + let block_contents = BlockContents::::from_ssz_bytes(&block_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); @@ -2611,7 +2610,7 @@ impl ApiTester { let block = self .client - .get_validator_blocks_modular::>( + .get_validator_blocks_modular::( slot, &Signature::infinity().unwrap().into(), None, @@ -2669,13 +2668,13 @@ impl ApiTester { // Check failure with no `skip_randao_verification` passed. self.client - .get_validator_blocks::>(slot, &bad_randao_reveal, None) + .get_validator_blocks::(slot, &bad_randao_reveal, None) .await .unwrap_err(); // Check failure with `skip_randao_verification` (requires infinity sig). self.client - .get_validator_blocks_modular::>( + .get_validator_blocks_modular::( slot, &bad_randao_reveal, None, @@ -2690,7 +2689,7 @@ impl ApiTester { self } - pub async fn test_blinded_block_production>(&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; @@ -2730,29 +2729,33 @@ impl ApiTester { let block = self .client - .get_validator_blinded_blocks::(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data; - let signed_block_contents = - block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); - dbg!(&signed_block_contents); + let signed_block = block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); + dbg!(&signed_block); self.client - .post_beacon_blinded_blocks(&signed_block_contents) + .post_beacon_blinded_blocks(&signed_block) .await .unwrap(); - // This converts the generic `Payload` to a concrete type for comparison. - let signed_block = signed_block_contents.deconstruct().0; - let head_block = SignedBeaconBlock::from(signed_block.clone()); - assert_eq!(head_block, signed_block); + let head_block = self + .client + .get_beacon_blocks(CoreBlockId::Head) + .await + .unwrap() + .unwrap() + .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) { + 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; @@ -2792,43 +2795,47 @@ impl ApiTester { let block_contents_bytes = self .client - .get_validator_blinded_blocks_ssz::(slot, &randao_reveal, None) + .get_validator_blinded_blocks_ssz::(slot, &randao_reveal, None) .await .unwrap() .expect("block bytes"); - let block_contents = BlockContents::::from_ssz_bytes( - &block_contents_bytes, - &self.chain.spec, - ) - .expect("block contents bytes can be decoded"); + let block_contents = + BlockContents::::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) + .post_beacon_blinded_blocks_ssz( + &signed_block_contents.signed_block().clone_as_blinded(), + ) .await .unwrap(); - // This converts the generic `Payload` to a concrete type for comparison. - let signed_block = signed_block_contents.deconstruct().0; - let head_block = SignedBeaconBlock::from(signed_block.clone()); - assert_eq!(head_block, signed_block); + let head_block = self + .client + .get_beacon_blocks(CoreBlockId::Head) + .await + .unwrap() + .unwrap() + .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 { + 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 block_contents = self + let blinded_block = self .client - .get_validator_blinded_blocks_modular::( + .get_validator_blinded_blocks_modular::( slot, &Signature::infinity().unwrap().into(), None, @@ -2837,18 +2844,14 @@ impl ApiTester { .await .unwrap() .data; - assert_eq!(block_contents.block().slot(), slot); + 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< - Payload: AbstractExecPayload, - >( - self, - ) -> 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; @@ -2888,13 +2891,13 @@ impl ApiTester { // Check failure with full randao verification enabled. self.client - .get_validator_blinded_blocks::(slot, &bad_randao_reveal, None) + .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::( + .get_validator_blinded_blocks_modular::( slot, &bad_randao_reveal, None, @@ -3369,11 +3372,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3410,11 +3412,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3453,11 +3454,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3502,11 +3502,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3549,11 +3548,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3596,11 +3594,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3642,11 +3639,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3675,11 +3671,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3713,11 +3708,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3757,11 +3751,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(next_slot, &randao_reveal, None) + .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3787,11 +3780,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(next_slot, &randao_reveal, None) + .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3837,11 +3829,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(next_slot, &randao_reveal, None) + .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3877,11 +3868,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(next_slot, &randao_reveal, None) + .get_validator_blinded_blocks::(next_slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3921,11 +3911,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3962,11 +3951,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -3999,11 +3987,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -4036,11 +4023,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -4073,11 +4059,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -4109,11 +4094,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -4145,17 +4129,13 @@ impl ApiTester { let block_contents = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data; - let (block, maybe_sidecars) = block_contents.deconstruct(); - - // Response should contain blob sidecars - assert!(maybe_sidecars.is_some()); // The builder's payload should've been chosen, so this cache should not be populated - let payload: BlindedPayload = block.body().execution_payload().unwrap().into(); + let payload: BlindedPayload = block_contents.body().execution_payload().unwrap().into(); assert!(self .chain .execution_layer @@ -4186,11 +4166,10 @@ impl ApiTester { let payload: BlindedPayload = self .client - .get_validator_blinded_blocks::>(slot, &randao_reveal, None) + .get_validator_blinded_blocks::(slot, &randao_reveal, None) .await .unwrap() .data - .block() .body() .execution_payload() .unwrap() @@ -4836,13 +4815,13 @@ async fn post_beacon_blocks_ssz_valid() { .await; } -// #[tokio::test(flavor = "multi_thread", worker_threads = 2)] -// async fn test_post_beacon_blocks_ssz_invalid() { -// ApiTester::new() -// .await -// .test_post_beacon_blocks_ssz_invalid() -// .await; -// } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn test_post_beacon_blocks_ssz_invalid() { + ApiTester::new() + .await + .test_post_beacon_blocks_ssz_invalid() + .await; +} #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn post_beacon_blocks_invalid() { @@ -5056,17 +5035,14 @@ async fn block_production_ssz_with_skip_slots() { #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn blinded_block_production_full_payload_premerge() { - ApiTester::new() - .await - .test_blinded_block_production::>() - .await; + 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::>() + .test_blinded_block_production_ssz() .await; } @@ -5075,7 +5051,7 @@ 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::>() + .test_blinded_block_production() .await; } @@ -5084,7 +5060,7 @@ 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::>() + .test_blinded_block_production_ssz() .await; } @@ -5092,7 +5068,7 @@ async fn blinded_block_production_ssz_with_skip_slots_full_payload_premerge() { async fn blinded_block_production_no_verify_randao_full_payload_premerge() { ApiTester::new() .await - .test_blinded_block_production_no_verify_randao::>() + .test_blinded_block_production_no_verify_randao() .await; } @@ -5100,16 +5076,13 @@ async fn blinded_block_production_no_verify_randao_full_payload_premerge() { async fn blinded_block_production_verify_randao_invalid_full_payload_premerge() { ApiTester::new() .await - .test_blinded_block_production_verify_randao_invalid::>() + .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; + ApiTester::new().await.test_blinded_block_production().await; } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] @@ -5117,7 +5090,7 @@ 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::>() + .test_blinded_block_production() .await; } @@ -5125,7 +5098,7 @@ async fn blinded_block_production_with_skip_slots_blinded_payload_premerge() { async fn blinded_block_production_no_verify_randao_blinded_payload_premerge() { ApiTester::new() .await - .test_blinded_block_production_no_verify_randao::>() + .test_blinded_block_production_no_verify_randao() .await; } @@ -5133,7 +5106,7 @@ async fn blinded_block_production_no_verify_randao_blinded_payload_premerge() { async fn blinded_block_production_verify_randao_invalid_blinded_payload_premerge() { ApiTester::new() .await - .test_blinded_block_production_verify_randao_invalid::>() + .test_blinded_block_production_verify_randao_invalid() .await; } diff --git a/common/eth2/src/lib.rs b/common/eth2/src/lib.rs index b3ca1d131d8..f89e611be62 100644 --- a/common/eth2/src/lib.rs +++ b/common/eth2/src/lib.rs @@ -711,7 +711,7 @@ impl BeaconNodeHttpClient { /// `POST beacon/blocks` /// /// Returns `Ok(None)` on a 404 error. - pub async fn post_beacon_blocks_ssz>( + pub async fn post_beacon_blocks_ssz( &self, block_contents: &SignedBlockContents, ) -> Result<(), Error> { @@ -755,7 +755,7 @@ impl BeaconNodeHttpClient { /// `POST beacon/blinded_blocks` /// /// Returns `Ok(None)` on a 404 error. - pub async fn post_beacon_blinded_blocks_ssz>( + pub async fn post_beacon_blinded_blocks_ssz( &self, block: &SignedBlindedBeaconBlock, ) -> Result<(), Error> { @@ -809,7 +809,7 @@ impl BeaconNodeHttpClient { } /// `POST v2/beacon/blocks` - pub async fn post_beacon_blocks_v2>( + pub async fn post_beacon_blocks_v2( &self, block_contents: &SignedBlockContents, validation_level: Option, @@ -826,7 +826,7 @@ impl BeaconNodeHttpClient { } /// `POST v2/beacon/blocks` - pub async fn post_beacon_blocks_v2_ssz>( + pub async fn post_beacon_blocks_v2_ssz( &self, block_contents: &SignedBlockContents, validation_level: Option, From c12db38ea5ae059c680d837251eac31fd700af89 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Fri, 17 Nov 2023 08:17:04 -0500 Subject: [PATCH 7/9] fix lints --- beacon_node/beacon_chain/src/beacon_chain.rs | 12 +-- .../beacon_chain/src/blob_verification.rs | 19 +++- .../beacon_chain/src/block_verification.rs | 2 +- .../overflow_lru_cache.rs | 2 +- .../beacon_chain/tests/block_verification.rs | 100 ++++++++---------- .../gossip_methods.rs | 3 +- .../src/network_beacon_processor/tests.rs | 29 ++--- consensus/types/src/beacon_block_body.rs | 18 ++-- consensus/types/src/blob_sidecar.rs | 52 ++++++--- consensus/types/src/signed_beacon_block.rs | 2 +- testing/ef_tests/Makefile | 2 +- 11 files changed, 135 insertions(+), 106 deletions(-) diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index 3357308e289..e138ebd94b3 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -492,22 +492,22 @@ pub enum BeaconBlockResponseType { impl BeaconBlockResponseType { pub fn fork_name(&self, spec: &ChainSpec) -> Result { Ok(match self { - BeaconBlockResponseType::Full(resp) => resp.block.to_ref().fork_name(&spec)?, - BeaconBlockResponseType::Blinded(resp) => resp.block.to_ref().fork_name(&spec)?, + BeaconBlockResponseType::Full(resp) => resp.block.to_ref().fork_name(spec)?, + BeaconBlockResponseType::Blinded(resp) => resp.block.to_ref().fork_name(spec)?, }) } pub fn execution_payload_value(&self) -> Option { match self { - BeaconBlockResponseType::Full(resp) => resp.execution_payload_value.clone(), - BeaconBlockResponseType::Blinded(resp) => resp.execution_payload_value.clone(), + BeaconBlockResponseType::Full(resp) => resp.execution_payload_value, + BeaconBlockResponseType::Blinded(resp) => resp.execution_payload_value, } } pub fn consensus_block_value(&self) -> Option { match self { - BeaconBlockResponseType::Full(resp) => resp.consensus_block_value.clone(), - BeaconBlockResponseType::Blinded(resp) => resp.consensus_block_value.clone(), + BeaconBlockResponseType::Full(resp) => resp.consensus_block_value, + BeaconBlockResponseType::Blinded(resp) => resp.consensus_block_value, } } diff --git a/beacon_node/beacon_chain/src/blob_verification.rs b/beacon_node/beacon_chain/src/blob_verification.rs index 8c5f7786994..cd1572ef20f 100644 --- a/beacon_node/beacon_chain/src/blob_verification.rs +++ b/beacon_node/beacon_chain/src/blob_verification.rs @@ -8,6 +8,7 @@ use crate::block_verification::cheap_state_advance_to_obtain_committees; use crate::kzg_utils::{validate_blob, validate_blobs}; use crate::{metrics, BeaconChainError}; use kzg::{Error as KzgError, Kzg, KzgCommitment}; +use merkle_proof::MerkleTreeError; use slog::{debug, warn}; use ssz_derive::{Decode, Encode}; use ssz_types::VariableList; @@ -123,6 +124,13 @@ pub enum GossipBlobError { /// /// The blob sidecar is invalid and the peer is faulty. KzgError(kzg::Error), + + /// The kzg commitment inclusion proof failed. + /// + /// ## Peer scoring + /// + /// The blob sidecar is invalid + InclusionProof(MerkleTreeError), } impl std::fmt::Display for GossipBlobError { @@ -265,8 +273,8 @@ pub fn verify_kzg_for_blob( blob: Arc>, kzg: &Kzg, ) -> Result, KzgError> { - let _timer = crate::metrics::start_timer(&crate::metrics::KZG_VERIFICATION_SINGLE_TIMES); - let _ = validate_blob::(kzg, &blob.blob, blob.kzg_commitment, blob.kzg_proof)?; + let _timer = metrics::start_timer(&crate::metrics::KZG_VERIFICATION_SINGLE_TIMES); + validate_blob::(kzg, &blob.blob, blob.kzg_commitment, blob.kzg_proof)?; Ok(KzgVerifiedBlob { blob }) } @@ -359,7 +367,10 @@ pub fn validate_blob_sidecar_for_gossip( } // Verify the inclusion proof in the sidecar - if !blob_sidecar.verify_blob_sidecar_inclusion_proof() { + if !blob_sidecar + .verify_blob_sidecar_inclusion_proof() + .map_err(GossipBlobError::InclusionProof)? + { return Err(GossipBlobError::InvalidInclusionProof); } @@ -521,7 +532,7 @@ pub fn validate_blob_sidecar_for_gossip( .as_ref() .ok_or(GossipBlobError::KzgNotInitialized)?; let kzg_verified_blob = - verify_kzg_for_blob(blob_sidecar, &kzg).map_err(GossipBlobError::KzgError)?; + verify_kzg_for_blob(blob_sidecar, kzg).map_err(GossipBlobError::KzgError)?; Ok(GossipVerifiedBlob { blob: kzg_verified_blob, diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs index 874c6aadb55..27d6a4d08a0 100644 --- a/beacon_node/beacon_chain/src/block_verification.rs +++ b/beacon_node/beacon_chain/src/block_verification.rs @@ -702,7 +702,7 @@ impl IntoGossipVerifiedBlockContents for SignedBlockCont gossip_verified_blobs.push(gossip_verified_blob); } let gossip_verified_blobs = VariableList::from(gossip_verified_blobs); - Ok::<_, BlockContentsError>(VariableList::from(gossip_verified_blobs)) + Ok::<_, BlockContentsError>(gossip_verified_blobs) }) .transpose()?; let gossip_verified_block = GossipVerifiedBlock::new(Arc::new(block), chain)?; diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs index 3b3875384bd..a86a329224e 100644 --- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs +++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs @@ -919,7 +919,7 @@ mod test { info!(log, "done printing kzg commitments"); let gossip_verified_blobs = if let Some((kzg_proofs, blobs)) = maybe_blobs { - let sidecars = BlobSidecar::build_sidecars(blobs, &block, kzg_proofs.into()).unwrap(); + let sidecars = BlobSidecar::build_sidecars(blobs, &block, kzg_proofs).unwrap(); Vec::from(sidecars) .into_iter() .map(|sidecar| { diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs index 174a4bf6212..7f7c868ac6a 100644 --- a/beacon_node/beacon_chain/tests/block_verification.rs +++ b/beacon_node/beacon_chain/tests/block_verification.rs @@ -112,7 +112,7 @@ async fn get_chain_segment_with_blob_sidecars( .chain .get_blobs(&snapshot.beacon_block_root) .unwrap(); - segment_blobs.push(Some(VariableList::from(blob_sidecars))) + segment_blobs.push(Some(blob_sidecars)) } (segment, segment_blobs) } @@ -140,7 +140,7 @@ fn chain_segment_blocks( ) -> Vec> { chain_segment .iter() - .zip(blobs.into_iter()) + .zip(blobs.iter()) .map(|(snapshot, blobs)| { RpcBlock::new(None, snapshot.beacon_block.clone(), blobs.clone()).unwrap() }) @@ -228,7 +228,6 @@ async fn chain_segment_full_segment() { let (chain_segment, chain_segment_blobs) = get_chain_segment().await; let blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); harness @@ -267,7 +266,6 @@ async fn chain_segment_varying_chunk_size() { let (chain_segment, chain_segment_blobs) = get_chain_segment().await; let blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); harness @@ -309,7 +307,6 @@ async fn chain_segment_non_linear_parent_roots() { */ let mut blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); blocks.remove(2); @@ -330,7 +327,6 @@ async fn chain_segment_non_linear_parent_roots() { */ let mut blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); let (mut block, signature) = blocks[3].as_block().clone().deconstruct(); @@ -368,7 +364,6 @@ async fn chain_segment_non_linear_slots() { let mut blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); let (mut block, signature) = blocks[3].as_block().clone().deconstruct(); *block.slot_mut() = Slot::new(0); @@ -395,7 +390,6 @@ async fn chain_segment_non_linear_slots() { let mut blocks: Vec> = chain_segment_blocks(&chain_segment, &chain_segment_blobs) .into_iter() - .map(|block| block.into()) .collect(); let (mut block, signature) = blocks[3].as_block().clone().deconstruct(); *block.slot_mut() = blocks[2].slot(); @@ -923,7 +917,7 @@ async fn block_gossip_verification() { *block.slot_mut() = expected_block_slot; assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature)).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await), BlockError::FutureSlot { present_slot, block_slot, @@ -957,7 +951,7 @@ async fn block_gossip_verification() { *block.slot_mut() = expected_finalized_slot; assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature)).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await), BlockError::WouldRevertFinalizedSlot { block_slot, finalized_slot, @@ -987,9 +981,10 @@ async fn block_gossip_verification() { unwrap_err( harness .chain - .verify_block_for_gossip( - Arc::new(SignedBeaconBlock::from_block(block, junk_signature())).into() - ) + .verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block( + block, + junk_signature() + ))) .await ), BlockError::ProposalSignatureInvalid @@ -1014,7 +1009,7 @@ async fn block_gossip_verification() { *block.parent_root_mut() = parent_root; assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature)).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await), BlockError::ParentUnknown(block) if block.parent_root() == parent_root ), @@ -1040,7 +1035,7 @@ async fn block_gossip_verification() { *block.parent_root_mut() = parent_root; assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature)).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(SignedBeaconBlock::from_block(block, signature))).await), BlockError::NotFinalizedDescendant { block_parent_root } if block_parent_root == parent_root ), @@ -1066,7 +1061,6 @@ async fn block_gossip_verification() { .0; let expected_proposer = block.proposer_index(); let other_proposer = (0..VALIDATOR_COUNT as u64) - .into_iter() .find(|i| *i != block.proposer_index()) .expect("there must be more than one validator in this test"); *block.proposer_index_mut() = other_proposer; @@ -1078,7 +1072,7 @@ async fn block_gossip_verification() { ); assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(block.clone()).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(block.clone())).await), BlockError::IncorrectBlockProposer { block, local_shuffling, @@ -1090,7 +1084,7 @@ async fn block_gossip_verification() { // Check to ensure that we registered this is a valid block from this proposer. assert!( matches!( - unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(block.clone()).into()).await), + unwrap_err(harness.chain.verify_block_for_gossip(Arc::new(block.clone())).await), BlockError::BlockIsAlreadyKnown, ), "should register any valid signature against the proposer, even if the block failed later verification" @@ -1116,10 +1110,9 @@ async fn block_gossip_verification() { matches!( harness .chain - .verify_block_for_gossip(block.clone().into()) + .verify_block_for_gossip(block.clone()) .await - .err() - .expect("should error when processing known block"), + .expect_err("should error when processing known block"), BlockError::BlockIsAlreadyKnown ), "the second proposal by this validator should be rejected" @@ -1345,10 +1338,9 @@ async fn add_base_block_to_altair_chain() { assert!(matches!( harness .chain - .verify_block_for_gossip(Arc::new(base_block.clone()).into()) + .verify_block_for_gossip(Arc::new(base_block.clone())) .await - .err() - .expect("should error when processing base block"), + .expect_err("should error when processing base block"), BlockError::InconsistentFork(InconsistentFork { fork_at_slot: ForkName::Altair, object_fork: ForkName::Base, @@ -1366,8 +1358,7 @@ async fn add_base_block_to_altair_chain() { || Ok(()), ) .await - .err() - .expect("should error when processing base block"), + .expect_err("should error when processing base block"), BlockError::InconsistentFork(InconsistentFork { fork_at_slot: ForkName::Altair, object_fork: ForkName::Base, @@ -1483,10 +1474,9 @@ async fn add_altair_block_to_base_chain() { assert!(matches!( harness .chain - .verify_block_for_gossip(Arc::new(altair_block.clone()).into()) + .verify_block_for_gossip(Arc::new(altair_block.clone())) .await - .err() - .expect("should error when processing altair block"), + .expect_err("should error when processing altair block"), BlockError::InconsistentFork(InconsistentFork { fork_at_slot: ForkName::Base, object_fork: ForkName::Altair, @@ -1504,8 +1494,7 @@ async fn add_altair_block_to_base_chain() { || Ok(()), ) .await - .err() - .expect("should error when processing altair block"), + .expect_err("should error when processing altair block"), BlockError::InconsistentFork(InconsistentFork { fork_at_slot: ForkName::Base, object_fork: ForkName::Altair, @@ -1561,10 +1550,12 @@ async fn import_duplicate_block_unrealized_justification() { // The store's justified checkpoint must still be at epoch 0, while unrealized justification // must be at epoch 1. - let fc = chain.canonical_head.fork_choice_read_lock(); - assert_eq!(fc.justified_checkpoint().epoch, 0); - assert_eq!(fc.unrealized_justified_checkpoint().epoch, 1); - drop(fc); + { + let fc = chain.canonical_head.fork_choice_read_lock(); + assert_eq!(fc.justified_checkpoint().epoch, 0); + assert_eq!(fc.unrealized_justified_checkpoint().epoch, 1); + drop(fc); + } // Produce a block to justify epoch 2. let state = harness.get_current_state(); @@ -1579,10 +1570,10 @@ async fn import_duplicate_block_unrealized_justification() { let notify_execution_layer = NotifyExecutionLayer::Yes; let verified_block1 = block .clone() - .into_execution_pending_block(block_root, &chain, notify_execution_layer) + .into_execution_pending_block(block_root, chain, notify_execution_layer) .unwrap(); let verified_block2 = block - .into_execution_pending_block(block_root, &chain, notify_execution_layer) + .into_execution_pending_block(block_root, chain, notify_execution_layer) .unwrap(); // Import the first block, simulating a block processed via a finalized chain segment. @@ -1591,18 +1582,20 @@ async fn import_duplicate_block_unrealized_justification() { .unwrap(); // Unrealized justification should NOT have updated. - let fc = chain.canonical_head.fork_choice_read_lock(); - assert_eq!(fc.justified_checkpoint().epoch, 0); - let unrealized_justification = fc.unrealized_justified_checkpoint(); - assert_eq!(unrealized_justification.epoch, 2); - - // The fork choice node for the block should have unrealized justification. - let fc_block = fc.get_block(&block_root).unwrap(); - assert_eq!( - fc_block.unrealized_justified_checkpoint, - Some(unrealized_justification) - ); - drop(fc); + let unrealized_justification = { + let fc = chain.canonical_head.fork_choice_read_lock(); + assert_eq!(fc.justified_checkpoint().epoch, 0); + let unrealized_justification = fc.unrealized_justified_checkpoint(); + assert_eq!(unrealized_justification.epoch, 2); + // The fork choice node for the block should have unrealized justification. + let fc_block = fc.get_block(&block_root).unwrap(); + assert_eq!( + fc_block.unrealized_justified_checkpoint, + Some(unrealized_justification) + ); + drop(fc); + unrealized_justification + }; // Import the second verified block, simulating a block processed via RPC. import_execution_pending_block(chain.clone(), verified_block2) @@ -1610,15 +1603,16 @@ async fn import_duplicate_block_unrealized_justification() { .unwrap(); // Unrealized justification should still be updated. - let fc = chain.canonical_head.fork_choice_read_lock(); - assert_eq!(fc.justified_checkpoint().epoch, 0); + let fc3 = chain.canonical_head.fork_choice_read_lock(); + assert_eq!(fc3.justified_checkpoint().epoch, 0); assert_eq!( - fc.unrealized_justified_checkpoint(), + fc3.unrealized_justified_checkpoint(), unrealized_justification ); // The fork choice node for the block should still have the unrealized justified checkpoint. - let fc_block = fc.get_block(&block_root).unwrap(); + let fc_block = fc3.get_block(&block_root).unwrap(); + drop(fc3); assert_eq!( fc_block.unrealized_justified_checkpoint, Some(unrealized_justification) diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs index 2d8d1e670e8..bffd800a426 100644 --- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs +++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs @@ -690,7 +690,8 @@ impl NetworkBeaconProcessor { | GossipBlobError::BlobIsNotLaterThanParent { .. } | GossipBlobError::InvalidSubnet { .. } | GossipBlobError::InvalidInclusionProof - | GossipBlobError::KzgError(_) => { + | GossipBlobError::KzgError(_) + | GossipBlobError::InclusionProof(_) => { warn!( self.log, "Could not verify blob sidecar for gossip. Rejecting the blob sidecar"; diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs index fe97e9bf9fc..97597d14777 100644 --- a/beacon_node/network/src/network_beacon_processor/tests.rs +++ b/beacon_node/network/src/network_beacon_processor/tests.rs @@ -34,8 +34,8 @@ use tokio::sync::mpsc; use types::blob_sidecar::FixedBlobSidecarList; use types::{ Attestation, AttesterSlashing, BlobSidecar, BlobSidecarList, Epoch, Hash256, MainnetEthSpec, - ProposerSlashing, Sidecar, SignedAggregateAndProof, SignedBeaconBlock, SignedVoluntaryExit, - Slot, SubnetId, + ProposerSlashing, SignedAggregateAndProof, SignedBeaconBlock, SignedVoluntaryExit, Slot, + SubnetId, }; type E = MainnetEthSpec; @@ -186,8 +186,10 @@ impl TestRig { let log = harness.logger().clone(); - let mut beacon_processor_config = BeaconProcessorConfig::default(); - beacon_processor_config.enable_backfill_rate_limiting = enable_backfill_rate_limiting; + let beacon_processor_config = BeaconProcessorConfig { + enable_backfill_rate_limiting, + ..Default::default() + }; let BeaconProcessorChannels { beacon_processor_tx, beacon_processor_rx, @@ -243,18 +245,10 @@ impl TestRig { chain.spec.maximum_gossip_clock_disparity(), ); - assert!(!beacon_processor.is_err()); + assert!(beacon_processor.is_ok()); let block = next_block_tuple.0; let blob_sidecars = if let Some((kzg_proofs, blobs)) = next_block_tuple.1 { - Some( - BlobSidecar::build_sidecar( - blobs, - &block, - block.message().body().blob_kzg_commitments().unwrap(), - kzg_proofs.into(), - ) - .unwrap(), - ) + Some(BlobSidecar::build_sidecars(blobs, &block, kzg_proofs).unwrap()) } else { None }; @@ -319,7 +313,7 @@ impl TestRig { self.network_beacon_processor .send_rpc_beacon_block( block_root, - RpcBlock::new_without_blobs(Some(block_root), self.next_block.clone().into()), + RpcBlock::new_without_blobs(Some(block_root), self.next_block.clone()), std::time::Duration::default(), BlockProcessType::ParentLookup { chain_hash: Hash256::random(), @@ -333,7 +327,7 @@ impl TestRig { self.network_beacon_processor .send_rpc_beacon_block( block_root, - RpcBlock::new_without_blobs(Some(block_root), self.next_block.clone().into()), + RpcBlock::new_without_blobs(Some(block_root), self.next_block.clone()), std::time::Duration::default(), BlockProcessType::SingleBlock { id: 1 }, ) @@ -341,8 +335,7 @@ impl TestRig { } pub fn enqueue_single_lookup_rpc_blobs(&self) { if let Some(blobs) = self.next_blobs.clone() { - let blobs = - FixedBlobSidecarList::from(blobs.into_iter().map(|b| Some(b)).collect::>()); + let blobs = FixedBlobSidecarList::from(blobs.into_iter().map(Some).collect::>()); self.network_beacon_processor .send_rpc_blobs( self.next_block.canonical_root(), diff --git a/consensus/types/src/beacon_block_body.rs b/consensus/types/src/beacon_block_body.rs index 97996a12832..12961957056 100644 --- a/consensus/types/src/beacon_block_body.rs +++ b/consensus/types/src/beacon_block_body.rs @@ -1,6 +1,7 @@ use crate::test_utils::TestRandom; use crate::*; use derivative::Derivative; +use merkle_proof::{MerkleTree, MerkleTreeError}; use serde::{Deserialize, Serialize}; use ssz_derive::{Decode, Encode}; use ssz_types::VariableList; @@ -111,9 +112,11 @@ impl<'a, T: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, T, pub fn kzg_commitment_merkle_proof( &self, index: usize, - ) -> Option> { + ) -> Result, Error> { match self { - Self::Base(_) | Self::Altair(_) | Self::Merge(_) | Self::Capella(_) => None, + Self::Base(_) | Self::Altair(_) | Self::Merge(_) | Self::Capella(_) => { + Err(Error::IncorrectStateVariant) + } Self::Deneb(body) => { // We compute the branches by generating 2 merkle trees: // 1. Merkle tree for the `blob_kzg_commitments` List object @@ -131,7 +134,7 @@ impl<'a, T: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, T, .iter() .map(|commitment| commitment.tree_hash_root()) .collect(); - let tree = merkle_proof::MerkleTree::create(&leaves, depth as usize); + let tree = MerkleTree::create(&leaves, depth as usize); let (_, mut proof) = tree .generate_proof(index, depth as usize) .expect("Merkle tree consists of just leaf nodes"); @@ -140,7 +143,10 @@ impl<'a, T: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, T, let length = body.blob_kzg_commitments.len(); let usize_len = std::mem::size_of::(); let mut length_bytes = [0; BYTES_PER_CHUNK]; - length_bytes[0..usize_len].copy_from_slice(&length.to_le_bytes()); + length_bytes + .get_mut(0..usize_len) + .ok_or(Error::MerkleTreeError(MerkleTreeError::PleaseNotifyTheDevs))? + .copy_from_slice(&length.to_le_bytes()); let length_root = Hash256::from_slice(length_bytes.as_slice()); proof.push(length_root); @@ -160,7 +166,7 @@ impl<'a, T: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, T, body.bls_to_execution_changes.tree_hash_root(), body.blob_kzg_commitments.tree_hash_root(), ]; - let tree = merkle_proof::MerkleTree::create(&leaves, BEACON_BLOCK_BODY_TREE_DEPTH); + let tree = MerkleTree::create(&leaves, BEACON_BLOCK_BODY_TREE_DEPTH); let (_, mut proof_body) = tree .generate_proof(BLOB_KZG_COMMITMENTS_INDEX, BEACON_BLOCK_BODY_TREE_DEPTH) .expect("Merkle tree consists of just leaf nodes"); @@ -168,7 +174,7 @@ impl<'a, T: EthSpec, Payload: AbstractExecPayload> BeaconBlockBodyRef<'a, T, proof.append(&mut proof_body); debug_assert_eq!(proof.len(), T::kzg_proof_inclusion_proof_depth()); - Some(proof.into()) + Ok(proof.into()) } } } diff --git a/consensus/types/src/blob_sidecar.rs b/consensus/types/src/blob_sidecar.rs index 22eb5e1bfd4..d69c5cf0862 100644 --- a/consensus/types/src/blob_sidecar.rs +++ b/consensus/types/src/blob_sidecar.rs @@ -1,7 +1,7 @@ use crate::test_utils::TestRandom; use crate::{ - beacon_block_body::BLOB_KZG_COMMITMENTS_INDEX, BeaconBlockHeader, Blob, EthSpec, Hash256, - SignedBeaconBlockHeader, Slot, + beacon_block_body::BLOB_KZG_COMMITMENTS_INDEX, BeaconBlockHeader, BeaconStateError, Blob, + EthSpec, Hash256, SignedBeaconBlockHeader, Slot, }; use crate::{KzgProofs, SignedBeaconBlock}; use bls::Signature; @@ -10,8 +10,9 @@ use kzg::{ Blob as KzgBlob, Kzg, KzgCommitment, KzgProof, BYTES_PER_BLOB, BYTES_PER_FIELD_ELEMENT, FIELD_ELEMENTS_PER_BLOB, }; -use merkle_proof::{merkle_root_from_branch, verify_merkle_proof}; +use merkle_proof::{merkle_root_from_branch, verify_merkle_proof, MerkleTreeError}; use rand::Rng; +use safe_arith::{ArithError, SafeArith}; use serde::{Deserialize, Serialize}; use ssz::Encode; use ssz_derive::{Decode, Encode}; @@ -99,6 +100,27 @@ impl Ord for BlobSidecar { pub enum BlobSidecarError { PreDeneb, MissingKzgCommitment, + BeaconState(BeaconStateError), + MerkleTree(MerkleTreeError), + ArithError(ArithError), +} + +impl From for BlobSidecarError { + fn from(e: BeaconStateError) -> Self { + BlobSidecarError::BeaconState(e) + } +} + +impl From for BlobSidecarError { + fn from(e: MerkleTreeError) -> Self { + BlobSidecarError::MerkleTree(e) + } +} + +impl From for BlobSidecarError { + fn from(e: ArithError) -> Self { + BlobSidecarError::ArithError(e) + } } impl BlobSidecar { @@ -120,8 +142,7 @@ impl BlobSidecar { let kzg_commitment_inclusion_proof = signed_block .message() .body() - .kzg_commitment_merkle_proof(index) - .ok_or(BlobSidecarError::PreDeneb)?; + .kzg_commitment_merkle_proof(index)?; Ok(Self { index: index as u64, @@ -179,30 +200,33 @@ impl BlobSidecar { } /// Verifies the kzg commitment inclusion merkle proof. - pub fn verify_blob_sidecar_inclusion_proof(&self) -> bool { + pub fn verify_blob_sidecar_inclusion_proof(&self) -> Result { // Depth of the subtree rooted at `blob_kzg_commitments` in the `BeaconBlockBody` // is equal to depth of the ssz List max size + 1 for the length mixin let kzg_commitments_tree_depth = (T::max_blob_commitments_per_block() .next_power_of_two() .ilog2() - + 1) as usize; + .safe_add(1))? as usize; // Compute the `tree_hash_root` of the `blob_kzg_commitments` subtree using the // inclusion proof branches let blob_kzg_commitments_root = merkle_root_from_branch( self.kzg_commitment.tree_hash_root(), - &self.kzg_commitment_inclusion_proof[0..kzg_commitments_tree_depth], + self.kzg_commitment_inclusion_proof + .get(0..kzg_commitments_tree_depth) + .ok_or(MerkleTreeError::PleaseNotifyTheDevs)?, kzg_commitments_tree_depth, self.index as usize, ); // The remaining inclusion proof branches are for the top level `BeaconBlockBody` tree - verify_merkle_proof( + Ok(verify_merkle_proof( blob_kzg_commitments_root, - &self.kzg_commitment_inclusion_proof - [kzg_commitments_tree_depth..T::kzg_proof_inclusion_proof_depth()], - T::kzg_proof_inclusion_proof_depth() - kzg_commitments_tree_depth, + self.kzg_commitment_inclusion_proof + .get(kzg_commitments_tree_depth..T::kzg_proof_inclusion_proof_depth()) + .ok_or(MerkleTreeError::PleaseNotifyTheDevs)?, + T::kzg_proof_inclusion_proof_depth().safe_sub(kzg_commitments_tree_depth)?, BLOB_KZG_COMMITMENTS_INDEX, self.signed_block_header.message.body_root, - ) + )) } pub fn random_valid(rng: &mut R, kzg: &Kzg) -> Result { @@ -255,7 +279,7 @@ impl BlobSidecar { let mut blob_sidecars = vec![]; for (i, (kzg_proof, blob)) in kzg_proofs.iter().zip(blobs).enumerate() { let blob_sidecar = - BlobSidecar::new(i, blob, signed_block_header.clone(), &block, *kzg_proof)?; + BlobSidecar::new(i, blob, signed_block_header.clone(), block, *kzg_proof)?; blob_sidecars.push(Arc::new(blob_sidecar)); } Ok(VariableList::from(blob_sidecars)) diff --git a/consensus/types/src/signed_beacon_block.rs b/consensus/types/src/signed_beacon_block.rs index 559d6c126ce..58952ba18a6 100644 --- a/consensus/types/src/signed_beacon_block.rs +++ b/consensus/types/src/signed_beacon_block.rs @@ -229,7 +229,7 @@ impl> SignedBeaconBlock pub fn kzg_commitment_merkle_proof( &self, _index: usize, - ) -> Option> { + ) -> Result, Error> { self.message().body().kzg_commitment_merkle_proof(_index) } diff --git a/testing/ef_tests/Makefile b/testing/ef_tests/Makefile index 452d805ceca..e42db1801df 100644 --- a/testing/ef_tests/Makefile +++ b/testing/ef_tests/Makefile @@ -1,4 +1,4 @@ -TESTS_TAG := v1.4.0-beta.3 +TESTS_TAG := v1.4.0-beta.4 TESTS = general minimal mainnet TARBALLS = $(patsubst %,%-$(TESTS_TAG).tar.gz,$(TESTS)) From d683ef088ade52e1ab2ce92b2df13a347d125870 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Sat, 18 Nov 2023 15:57:38 -0500 Subject: [PATCH 8/9] fix existing spec tests --- beacon_node/http_api/tests/tests.rs | 2 +- consensus/types/src/signed_beacon_block.rs | 4 ++-- testing/ef_tests/src/cases/fork_choice.rs | 22 ++++++++++++++++------ testing/ef_tests/tests/tests.rs | 6 ------ 4 files changed, 19 insertions(+), 15 deletions(-) diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs index 8d0ee92a411..6ac2a71eac4 100644 --- a/beacon_node/http_api/tests/tests.rs +++ b/beacon_node/http_api/tests/tests.rs @@ -2735,7 +2735,7 @@ impl ApiTester { .data; let signed_block = block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec); - dbg!(&signed_block); + self.client .post_beacon_blinded_blocks(&signed_block) .await diff --git a/consensus/types/src/signed_beacon_block.rs b/consensus/types/src/signed_beacon_block.rs index 58952ba18a6..adf060a9d92 100644 --- a/consensus/types/src/signed_beacon_block.rs +++ b/consensus/types/src/signed_beacon_block.rs @@ -228,9 +228,9 @@ impl> SignedBeaconBlock /// Produces the proof of inclusion for a `KzgCommitment` in `self`. pub fn kzg_commitment_merkle_proof( &self, - _index: usize, + index: usize, ) -> Result, Error> { - self.message().body().kzg_commitment_merkle_proof(_index) + self.message().body().kzg_commitment_merkle_proof(index) } /// Convenience accessor for the block's slot. diff --git a/testing/ef_tests/src/cases/fork_choice.rs b/testing/ef_tests/src/cases/fork_choice.rs index 251acdda8c8..f9431dec418 100644 --- a/testing/ef_tests/src/cases/fork_choice.rs +++ b/testing/ef_tests/src/cases/fork_choice.rs @@ -1,6 +1,7 @@ use super::*; use crate::decode::{ssz_decode_file, ssz_decode_file_with, ssz_decode_state, yaml_decode_file}; use ::fork_choice::PayloadVerificationStatus; +use beacon_chain::blob_verification::GossipBlobError; use beacon_chain::slot_clock::SlotClock; use beacon_chain::{ attestation_verification::{ @@ -413,6 +414,8 @@ impl Tester { ) -> Result<(), Error> { let block_root = block.canonical_root(); + let mut blob_success = true; + // Convert blobs and kzg_proofs into sidecars, then plumb them into the availability tracker if let Some(blobs) = blobs.clone() { let proofs = kzg_proofs.unwrap(); @@ -440,11 +443,18 @@ impl Tester { signed_block_header: block.signed_block_header(), kzg_commitment_inclusion_proof: block.kzg_commitment_merkle_proof(i).unwrap(), }); - let result = self.block_on_dangerous( - self.harness - .chain - .process_gossip_blob(GossipVerifiedBlob::__assumed_valid(blob_sidecar)), - )?; + + let chain = self.harness.chain.clone(); + let blob = match GossipVerifiedBlob::new(blob_sidecar.clone(), &chain) { + Ok(gossip_verified_blob) => gossip_verified_blob, + Err(GossipBlobError::KzgError(_)) => { + blob_success = false; + GossipVerifiedBlob::__assumed_valid(blob_sidecar) + } + Err(_) => GossipVerifiedBlob::__assumed_valid(blob_sidecar), + }; + let result = + self.block_on_dangerous(self.harness.chain.process_gossip_blob(blob))?; if valid { assert!(result.is_ok()); } @@ -460,7 +470,7 @@ impl Tester { || Ok(()), ))? .map(|avail: AvailabilityProcessingStatus| avail.try_into()); - let success = result.as_ref().map_or(false, |inner| inner.is_ok()); + let success = blob_success && result.as_ref().map_or(false, |inner| inner.is_ok()); if success != valid { return Err(Error::DidntFail(format!( "block with root {} was valid={} whilst test expects valid={}. result: {:?}", diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs index d2d30b596cc..954fe19d3f7 100644 --- a/testing/ef_tests/tests/tests.rs +++ b/testing/ef_tests/tests/tests.rs @@ -378,12 +378,6 @@ mod ssz_static { SszStaticHandler::, MainnetEthSpec>::deneb_only().run(); } - #[test] - fn signed_blob_sidecar() { - SszStaticHandler::, MinimalEthSpec>::deneb_only().run(); - SszStaticHandler::, MainnetEthSpec>::deneb_only().run(); - } - #[test] fn blob_identifier() { SszStaticHandler::::deneb_only().run(); From 76b56e2c41a3f2e830866d5a6b90509ca0addd8e Mon Sep 17 00:00:00 2001 From: realbigsean Date: Sun, 19 Nov 2023 16:27:06 -0500 Subject: [PATCH 9/9] add new ef tests --- beacon_node/beacon_chain/src/beacon_chain.rs | 34 ++++---- consensus/fork_choice/src/fork_choice.rs | 2 +- consensus/fork_choice/src/lib.rs | 4 +- .../src/proto_array_fork_choice.rs | 6 +- testing/ef_tests/src/cases/fork_choice.rs | 82 ++++++++++++++++++- .../src/cases/merkle_proof_validity.rs | 64 ++++++++++++++- testing/ef_tests/src/handler.rs | 35 ++++++++ testing/ef_tests/tests/tests.rs | 22 ++++- 8 files changed, 224 insertions(+), 25 deletions(-) diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index e138ebd94b3..6b10a22174a 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -4410,23 +4410,27 @@ impl BeaconChain { &self, canonical_forkchoice_params: ForkchoiceUpdateParameters, ) -> Result { - self.overridden_forkchoice_update_params_or_failure_reason(&canonical_forkchoice_params) - .or_else(|e| match e { - ProposerHeadError::DoNotReOrg(reason) => { - trace!( - self.log, - "Not suppressing fork choice update"; - "reason" => %reason, - ); - Ok(canonical_forkchoice_params) - } - ProposerHeadError::Error(e) => Err(e), - }) + self.overridden_forkchoice_update_params_or_failure_reason( + &canonical_forkchoice_params, + false, + ) + .or_else(|e| match e { + ProposerHeadError::DoNotReOrg(reason) => { + trace!( + self.log, + "Not suppressing fork choice update"; + "reason" => %reason, + ); + Ok(canonical_forkchoice_params) + } + ProposerHeadError::Error(e) => Err(e), + }) } - fn overridden_forkchoice_update_params_or_failure_reason( + pub fn overridden_forkchoice_update_params_or_failure_reason( &self, canonical_forkchoice_params: &ForkchoiceUpdateParameters, + testing: bool, ) -> Result> { let _timer = metrics::start_timer(&metrics::FORK_CHOICE_OVERRIDE_FCU_TIMES); @@ -4478,7 +4482,7 @@ impl BeaconChain { } // Only attempt a re-org if we have a proposer registered for the re-org slot. - let proposing_at_re_org_slot = { + let proposing_at_re_org_slot = testing || { // The proposer shuffling has the same decision root as the next epoch attestation // shuffling. We know our re-org block is not on the epoch boundary, so it has the // same proposer shuffling as the head (but not necessarily the parent which may lie @@ -4533,7 +4537,7 @@ impl BeaconChain { // current slot, which would be necessary for determining its weight. let head_block_late = self.block_observed_after_attestation_deadline(head_block_root, head_slot); - if !head_block_late { + if !head_block_late && !testing { return Err(DoNotReOrg::HeadNotLate.into()); } diff --git a/consensus/fork_choice/src/fork_choice.rs b/consensus/fork_choice/src/fork_choice.rs index bdd74c1a2aa..865a5affbb9 100644 --- a/consensus/fork_choice/src/fork_choice.rs +++ b/consensus/fork_choice/src/fork_choice.rs @@ -291,7 +291,7 @@ pub enum AttestationFromBlock { } /// Parameters which are cached between calls to `ForkChoice::get_head`. -#[derive(Clone, Copy)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ForkchoiceUpdateParameters { /// The most recent result of running `ForkChoice::get_head`. pub head_root: Hash256, diff --git a/consensus/fork_choice/src/lib.rs b/consensus/fork_choice/src/lib.rs index e7ca84efb35..5e8cfb1ee49 100644 --- a/consensus/fork_choice/src/lib.rs +++ b/consensus/fork_choice/src/lib.rs @@ -7,4 +7,6 @@ pub use crate::fork_choice::{ QueuedAttestation, ResetPayloadStatuses, }; pub use fork_choice_store::ForkChoiceStore; -pub use proto_array::{Block as ProtoBlock, ExecutionStatus, InvalidationOperation}; +pub use proto_array::{ + Block as ProtoBlock, ExecutionStatus, InvalidationOperation, ProposerHeadError, +}; diff --git a/consensus/proto_array/src/proto_array_fork_choice.rs b/consensus/proto_array/src/proto_array_fork_choice.rs index 6fc677073ed..1c41b1855b7 100644 --- a/consensus/proto_array/src/proto_array_fork_choice.rs +++ b/consensus/proto_array/src/proto_array_fork_choice.rs @@ -188,7 +188,7 @@ where } /// Information about the proposer head used for opportunistic re-orgs. -#[derive(Clone)] +#[derive(Debug, Clone)] pub struct ProposerHeadInfo { /// Information about the *current* head block, which may be re-orged. pub head_node: ProtoNode, @@ -206,7 +206,7 @@ pub struct ProposerHeadInfo { /// /// This type intentionally does not implement `Debug` so that callers are forced to handle the /// enum. -#[derive(Clone, PartialEq)] +#[derive(Debug, Clone, PartialEq)] pub enum ProposerHeadError { DoNotReOrg(DoNotReOrg), Error(E), @@ -243,7 +243,7 @@ impl ProposerHeadError { /// Reasons why a re-org should not be attempted. /// /// This type intentionally does not implement `Debug` so that the `Display` impl must be used. -#[derive(Clone, PartialEq)] +#[derive(Debug, Clone, PartialEq)] pub enum DoNotReOrg { MissingHeadOrParentNode, MissingHeadFinalizedCheckpoint, diff --git a/testing/ef_tests/src/cases/fork_choice.rs b/testing/ef_tests/src/cases/fork_choice.rs index f9431dec418..58f53c0e7b1 100644 --- a/testing/ef_tests/src/cases/fork_choice.rs +++ b/testing/ef_tests/src/cases/fork_choice.rs @@ -1,7 +1,10 @@ use super::*; use crate::decode::{ssz_decode_file, ssz_decode_file_with, ssz_decode_state, yaml_decode_file}; -use ::fork_choice::PayloadVerificationStatus; +use ::fork_choice::{PayloadVerificationStatus, ProposerHeadError}; use beacon_chain::blob_verification::GossipBlobError; +use beacon_chain::chain_config::{ + DisallowedReOrgOffsets, DEFAULT_RE_ORG_MAX_EPOCHS_SINCE_FINALIZATION, DEFAULT_RE_ORG_THRESHOLD, +}; use beacon_chain::slot_clock::SlotClock; use beacon_chain::{ attestation_verification::{ @@ -39,6 +42,13 @@ pub struct Head { root: Hash256, } +#[derive(Debug, Clone, Copy, PartialEq, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ShouldOverrideFcu { + validator_is_connected: bool, + result: bool, +} + #[derive(Debug, Clone, Deserialize)] #[serde(deny_unknown_fields)] pub struct Checks { @@ -51,6 +61,8 @@ pub struct Checks { u_justified_checkpoint: Option, u_finalized_checkpoint: Option, proposer_boost_root: Option, + get_proposer_head: Option, + should_override_forkchoice_update: Option, } #[derive(Debug, Clone, Deserialize)] @@ -257,6 +269,8 @@ impl Case for ForkChoiceTest { u_justified_checkpoint, u_finalized_checkpoint, proposer_boost_root, + get_proposer_head, + should_override_forkchoice_update: should_override_fcu, } = checks.as_ref(); if let Some(expected_head) = head { @@ -295,6 +309,14 @@ impl Case for ForkChoiceTest { if let Some(expected_proposer_boost_root) = proposer_boost_root { tester.check_expected_proposer_boost_root(*expected_proposer_boost_root)?; } + + if let Some(expected_proposer_head) = get_proposer_head { + tester.check_expected_proposer_head(*expected_proposer_head)?; + } + + if let Some(should_override_fcu) = should_override_fcu { + tester.check_should_override_fcu(*should_override_fcu)?; + } } } } @@ -707,6 +729,64 @@ impl Tester { expected_proposer_boost_root, ) } + + pub fn check_expected_proposer_head( + &self, + expected_proposer_head: Hash256, + ) -> Result<(), Error> { + let mut fc = self.harness.chain.canonical_head.fork_choice_write_lock(); + let slot = self.harness.chain.slot().unwrap(); + let canonical_head = fc.get_head(slot, &self.harness.spec).unwrap(); + let proposer_head_result = fc.get_proposer_head( + slot, + canonical_head, + DEFAULT_RE_ORG_THRESHOLD, + &DisallowedReOrgOffsets::default(), + DEFAULT_RE_ORG_MAX_EPOCHS_SINCE_FINALIZATION, + ); + let proposer_head = match proposer_head_result { + Ok(head) => head.parent_node.root, + Err(ProposerHeadError::DoNotReOrg(_)) => canonical_head, + _ => panic!("Unexpected error in get proposer head"), + }; + + check_equal("proposer_head", proposer_head, expected_proposer_head) + } + + pub fn check_should_override_fcu( + &self, + expected_should_override_fcu: ShouldOverrideFcu, + ) -> Result<(), Error> { + let canonical_fcu_params = self + .harness + .chain + .canonical_head + .cached_head() + .forkchoice_update_parameters(); + let fcu_params_result = self + .harness + .chain + .overridden_forkchoice_update_params_or_failure_reason(&canonical_fcu_params, true); + + let should_override = match fcu_params_result { + Ok(_) => true, + Err(ProposerHeadError::DoNotReOrg(_)) => false, + _ => panic!("Unexpected error in fcu override"), + }; + + let should_override_fcu = ShouldOverrideFcu { + // Testing this doesn't really make sense because we don't call `override_forkchoice_update_params` + // unless a validator is connected. + validator_is_connected: expected_should_override_fcu.validator_is_connected, + result: should_override, + }; + + check_equal( + "proposer_head", + should_override_fcu, + expected_should_override_fcu, + ) + } } /// Checks that the `head` checkpoint from the beacon chain head matches the `fc` checkpoint gleaned diff --git a/testing/ef_tests/src/cases/merkle_proof_validity.rs b/testing/ef_tests/src/cases/merkle_proof_validity.rs index 0ba2c926633..0082f6c7f9e 100644 --- a/testing/ef_tests/src/cases/merkle_proof_validity.rs +++ b/testing/ef_tests/src/cases/merkle_proof_validity.rs @@ -1,9 +1,9 @@ use super::*; -use crate::decode::{ssz_decode_state, yaml_decode_file}; +use crate::decode::{ssz_decode_file, ssz_decode_state, yaml_decode_file}; use serde::Deserialize; use std::path::Path; use tree_hash::Hash256; -use types::{BeaconState, EthSpec, ForkName}; +use types::{BeaconBlockBody, BeaconBlockBodyDeneb, BeaconState, EthSpec, ForkName}; #[derive(Debug, Clone, Deserialize)] pub struct Metadata { @@ -82,3 +82,63 @@ impl Case for MerkleProofValidity { Ok(()) } } + +#[derive(Debug, Clone, Deserialize)] +#[serde(bound = "E: EthSpec")] +pub struct KzgInclusionMerkleProofValidity { + pub metadata: Option, + pub block: BeaconBlockBody, + pub merkle_proof: MerkleProof, +} + +impl LoadCase for KzgInclusionMerkleProofValidity { + fn load_from_dir(path: &Path, _fork_name: ForkName) -> Result { + //TODO(sean) make this work for all forks + let block = ssz_decode_file::>(&path.join("object.ssz_snappy"))?; + let merkle_proof = yaml_decode_file(&path.join("proof.yaml"))?; + // Metadata does not exist in these tests but it is left like this just in case. + let meta_path = path.join("meta.yaml"); + let metadata = if meta_path.exists() { + Some(yaml_decode_file(&meta_path)?) + } else { + None + }; + + Ok(Self { + metadata, + block: block.into(), + merkle_proof, + }) + } +} + +impl Case for KzgInclusionMerkleProofValidity { + fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> { + let Ok(proof) = self.block.to_ref().kzg_commitment_merkle_proof(0) else { + return Err(Error::FailedToParseTest( + "Could not retrieve merkle proof".to_string(), + )); + }; + let proof_len = proof.len(); + let branch_len = self.merkle_proof.branch.len(); + if proof_len != branch_len { + return Err(Error::NotEqual(format!( + "Branches not equal in length computed: {}, expected {}", + proof_len, branch_len + ))); + } + + for (i, proof_leaf) in proof.iter().enumerate().take(proof_len) { + let expected_leaf = self.merkle_proof.branch[i]; + if *proof_leaf != expected_leaf { + return Err(Error::NotEqual(format!( + "Leaves not equal in merke proof computed: {}, expected: {}", + hex::encode(proof_leaf), + hex::encode(expected_leaf) + ))); + } + } + + Ok(()) + } +} diff --git a/testing/ef_tests/src/handler.rs b/testing/ef_tests/src/handler.rs index 6dec9346291..0295ff1bd49 100644 --- a/testing/ef_tests/src/handler.rs +++ b/testing/ef_tests/src/handler.rs @@ -560,6 +560,13 @@ impl Handler for ForkChoiceHandler { return false; } + // No FCU override tests prior to bellatrix. + if self.handler_name == "should_override_forkchoice_update" + && (fork_name == ForkName::Base || fork_name == ForkName::Altair) + { + return false; + } + // These tests check block validity (which may include signatures) and there is no need to // run them with fake crypto. cfg!(not(feature = "fake_crypto")) @@ -786,6 +793,34 @@ impl Handler for MerkleProofValidityHandler { } } +#[derive(Derivative)] +#[derivative(Default(bound = ""))] +pub struct KzgInclusionMerkleProofValidityHandler(PhantomData); + +impl Handler for KzgInclusionMerkleProofValidityHandler { + type Case = cases::KzgInclusionMerkleProofValidity; + + fn config_name() -> &'static str { + E::name() + } + + fn runner_name() -> &'static str { + "merkle_proof" + } + + fn handler_name(&self) -> String { + "single_merkle_proof".into() + } + + fn is_enabled_for_fork(&self, fork_name: ForkName) -> bool { + // Enabled in Deneb + fork_name != ForkName::Base + && fork_name != ForkName::Altair + && fork_name != ForkName::Merge + && fork_name != ForkName::Capella + } +} + #[derive(Derivative)] #[derivative(Default(bound = ""))] pub struct OperationsHandler(PhantomData<(E, O)>); diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs index 954fe19d3f7..dd25dba8b60 100644 --- a/testing/ef_tests/tests/tests.rs +++ b/testing/ef_tests/tests/tests.rs @@ -1,7 +1,7 @@ #![cfg(feature = "ef_tests")] -use ef_tests::*; -use types::*; +use ef_tests::{KzgInclusionMerkleProofValidityHandler, *}; +use types::{MainnetEthSpec, MinimalEthSpec, *}; // Check that the hand-computed multiplications on EthSpec are correctly computed. // This test lives here because one is most likely to muck these up during a spec update. @@ -540,6 +540,18 @@ fn fork_choice_withholding() { // There is no mainnet variant for this test. } +#[test] +fn fork_choice_should_override_forkchoice_update() { + ForkChoiceHandler::::new("should_override_forkchoice_update").run(); + ForkChoiceHandler::::new("should_override_forkchoice_update").run(); +} + +#[test] +fn fork_choice_get_proposer_head() { + ForkChoiceHandler::::new("get_proposer_head").run(); + ForkChoiceHandler::::new("get_proposer_head").run(); +} + #[test] fn optimistic_sync() { OptimisticSyncHandler::::default().run(); @@ -592,6 +604,12 @@ fn merkle_proof_validity() { MerkleProofValidityHandler::::default().run(); } +#[test] +fn kzg_inclusion_merkle_proof_validity() { + KzgInclusionMerkleProofValidityHandler::::default().run(); + KzgInclusionMerkleProofValidityHandler::::default().run(); +} + #[test] fn rewards() { for handler in &["basic", "leak", "random"] {