From c0b27ad93b6e5e55bfe7fa9eeec9f274f397d703 Mon Sep 17 00:00:00 2001 From: Pawan Dhananjay Date: Tue, 7 Nov 2023 15:32:50 +0530 Subject: [PATCH] Tests compile --- .../overflow_lru_cache.rs | 35 ++++--- .../src/observed_blob_sidecars.rs | 1 + .../beacon_chain/tests/block_verification.rs | 95 ++++++++----------- beacon_node/beacon_chain/tests/events.rs | 21 ++-- beacon_node/http_api/src/publish_blocks.rs | 4 +- .../tests/broadcast_validation_tests.rs | 20 +--- .../http_api/tests/interactive_tests.rs | 6 +- .../src/network_beacon_processor/tests.rs | 39 +++++--- .../network/src/sync/block_lookups/tests.rs | 6 +- common/eth2/src/types.rs | 36 ++----- consensus/types/src/chain_spec.rs | 3 - 11 files changed, 116 insertions(+), 150 deletions(-) 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 ba968573a4c..a0f7990b5d0 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 @@ -755,7 +755,7 @@ mod test { use std::ops::AddAssign; use store::{HotColdDB, ItemStore, LevelDB, StoreConfig}; use tempfile::{tempdir, TempDir}; - use types::{ChainSpec, ExecPayload, MinimalEthSpec}; + use types::{ChainSpec, ExecPayload, MinimalEthSpec, Sidecar}; const LOW_VALIDATOR_COUNT: usize = 32; @@ -920,12 +920,23 @@ mod test { } info!(log, "done printing kzg commitments"); - let gossip_verified_blobs = if let Some(blobs) = maybe_blobs { - Vec::from(blobs) + 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(); + Vec::from(sidecars) .into_iter() - .map(|signed_blob| { - let subnet = signed_blob.message.index; - validate_blob_sidecar_for_gossip(signed_blob, subnet, &harness.chain) + .map(|sidecar| { + let subnet = sidecar.index; + validate_blob_sidecar_for_gossip(sidecar, subnet, &harness.chain) .expect("should validate blob") }) .collect() @@ -1038,7 +1049,7 @@ mod test { .expect("kzg should exist"); let mut kzg_verified_blobs = Vec::new(); for (blob_index, gossip_blob) in blobs.into_iter().enumerate() { - let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); kzg_verified_blobs.push(kzg_verified_blob); let availability = cache @@ -1066,7 +1077,7 @@ mod test { let root = pending_block.import_data.block_root; let mut kzg_verified_blobs = vec![]; for gossip_blob in blobs { - let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); kzg_verified_blobs.push(kzg_verified_blob); let availability = cache @@ -1203,7 +1214,7 @@ mod test { let expected_blobs = blobs_0.len(); let mut kzg_verified_blobs = vec![]; for (blob_index, gossip_blob) in blobs_0.into_iter().enumerate() { - let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); kzg_verified_blobs.push(kzg_verified_blob); let availability = cache @@ -1289,7 +1300,7 @@ mod test { let one_blob = pending_block_blobs .pop() .expect("should have at least one blob"); - let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(one_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); let kzg_verified_blobs = vec![kzg_verified_blob]; // generate random boolean @@ -1430,7 +1441,7 @@ mod test { let one_blob = pending_block_blobs .pop() .expect("should have at least one blob"); - let kzg_verified_blob = verify_kzg_for_blob(one_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(one_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); let kzg_verified_blobs = vec![kzg_verified_blob]; // generate random boolean @@ -1545,7 +1556,7 @@ mod test { let additional_blobs = blobs.len(); let mut kzg_verified_blobs = vec![]; for (i, gossip_blob) in blobs.into_iter().enumerate() { - let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.to_blob(), kzg.as_ref()) + let kzg_verified_blob = verify_kzg_for_blob(gossip_blob.into_inner(), kzg.as_ref()) .expect("kzg should verify"); kzg_verified_blobs.push(kzg_verified_blob); let availability = recovered_cache diff --git a/beacon_node/beacon_chain/src/observed_blob_sidecars.rs b/beacon_node/beacon_chain/src/observed_blob_sidecars.rs index 54d95bbf85f..cd14ebfdcd3 100644 --- a/beacon_node/beacon_chain/src/observed_blob_sidecars.rs +++ b/beacon_node/beacon_chain/src/observed_blob_sidecars.rs @@ -100,6 +100,7 @@ impl ObservedBlobSidecars { #[cfg(test)] mod tests { use super::*; + use std::sync::Arc; use types::{BlobSidecar, Hash256, MainnetEthSpec}; type E = MainnetEthSpec; diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs index 3ac39807146..f256bcdd5cb 100644 --- a/beacon_node/beacon_chain/tests/block_verification.rs +++ b/beacon_node/beacon_chain/tests/block_verification.rs @@ -1,7 +1,6 @@ -#![cfg(not(debug_assertions))] +// #![cfg(not(debug_assertions))] use beacon_chain::block_verification_types::{AsBlock, ExecutedBlock, RpcBlock}; -use beacon_chain::test_utils::BlobSignatureKey; use beacon_chain::{ test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType}, AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, ExecutionPendingBlock, @@ -77,10 +76,8 @@ async fn get_chain_segment() -> (Vec>, Vec ( - Vec>, - Vec, ::MaxBlobsPerBlock>>>, -) { +async fn get_chain_segment_with_blob_sidecars( +) -> (Vec>, Vec>>) { let harness = get_harness(VALIDATOR_COUNT); harness @@ -111,27 +108,11 @@ async fn get_chain_segment_with_signed_blobs() -> ( beacon_block: Arc::new(full_block), beacon_state: snapshot.beacon_state, }); - let signed_blobs = harness + let blob_sidecars = harness .chain .get_blobs(&snapshot.beacon_block_root) - .unwrap() - .into_iter() - .map(|blob| { - let block_root = blob.block_root; - let blob_index = blob.index; - SignedBlobSidecar { - message: blob, - signature: harness - .blob_signature_cache - .read() - .get(&BlobSignatureKey::new(block_root, blob_index)) - .unwrap() - .clone(), - _phantom: PhantomData, - } - }) - .collect::>(); - segment_blobs.push(Some(VariableList::from(signed_blobs))) + .unwrap(); + segment_blobs.push(Some(VariableList::from(blob_sidecars))) } (segment, segment_blobs) } @@ -214,34 +195,28 @@ fn update_parent_roots( let (mut block, signature) = child.beacon_block.as_ref().clone().deconstruct(); *block.parent_root_mut() = root; let new_child = Arc::new(SignedBeaconBlock::from_block(block, signature)); - let new_child_root = new_child.canonical_root(); - child.beacon_block = new_child; if let Some(blobs) = child_blobs { - update_blob_roots(new_child_root, blobs); + update_blob_signed_header(&new_child, blobs); } + child.beacon_block = new_child; } } } -fn update_blob_roots(block_root: Hash256, blobs: &mut BlobSidecarList) { +fn update_blob_signed_header( + signed_block: &SignedBeaconBlock, + blobs: &mut BlobSidecarList, +) { for old_blob_sidecar in blobs.iter_mut() { - let index = old_blob_sidecar.index; - let slot = old_blob_sidecar.slot; - let block_parent_root = old_blob_sidecar.block_parent_root; - let proposer_index = old_blob_sidecar.proposer_index; - let blob = old_blob_sidecar.blob.clone(); - let kzg_commitment = old_blob_sidecar.kzg_commitment; - let kzg_proof = old_blob_sidecar.kzg_proof; - let new_blob = Arc::new(BlobSidecar:: { - block_root, - index, - slot, - block_parent_root, - proposer_index, - blob, - kzg_commitment, - kzg_proof, + index: old_blob_sidecar.index, + blob: old_blob_sidecar.blob.clone(), + kzg_commitment: old_blob_sidecar.kzg_commitment, + kzg_proof: old_blob_sidecar.kzg_proof, + signed_block_header: signed_block.signed_block_header(), + kzg_commitment_inclusion_proof: signed_block + .kzg_commitment_merkle_proof(old_blob_sidecar.index as usize) + .unwrap(), }); *old_blob_sidecar = new_blob; } @@ -879,7 +854,7 @@ fn unwrap_err(result: Result) -> E { #[tokio::test] async fn block_gossip_verification() { let harness = get_harness(VALIDATOR_COUNT); - let (chain_segment, chain_segment_blobs) = get_chain_segment_with_signed_blobs().await; + let (chain_segment, chain_segment_blobs) = get_chain_segment_with_blob_sidecars().await; let block_index = CHAIN_SEGMENT_LENGTH - 2; @@ -909,12 +884,12 @@ async fn block_gossip_verification() { ) .await .expect("should import valid gossip verified block"); - if let Some(blobs) = blobs_opt { - for blob in blobs { - let blob_index = blob.message.index; + if let Some(blob_sidecars) = blobs_opt { + for blob_sidecar in blob_sidecars { + let blob_index = blob_sidecar.index; let gossip_verified = harness .chain - .verify_blob_sidecar_for_gossip(blob.clone(), blob_index) + .verify_blob_sidecar_for_gossip(blob_sidecar.clone(), blob_index) .expect("should obtain gossip verified blob"); harness @@ -1178,12 +1153,24 @@ async fn verify_block_for_gossip_slashing_detection() { .await .unwrap(); - if let Some(blobs) = blobs1 { - for blob in blobs { - let blob_index = blob.message.index; + 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(); + for sidecar in sidecars { + let blob_index = sidecar.index; let verified_blob = harness .chain - .verify_blob_sidecar_for_gossip(blob, blob_index) + .verify_blob_sidecar_for_gossip(sidecar, blob_index) .unwrap(); harness .chain diff --git a/beacon_node/beacon_chain/tests/events.rs b/beacon_node/beacon_chain/tests/events.rs index c48cf310a2a..ac46f231726 100644 --- a/beacon_node/beacon_chain/tests/events.rs +++ b/beacon_node/beacon_chain/tests/events.rs @@ -1,13 +1,12 @@ use beacon_chain::blob_verification::GossipVerifiedBlob; use beacon_chain::test_utils::BeaconChainHarness; -use bls::Signature; use eth2::types::{EventKind, SseBlobSidecar}; use rand::rngs::StdRng; use rand::SeedableRng; -use std::marker::PhantomData; +use std::ops::Deref; use std::sync::Arc; use types::blob_sidecar::FixedBlobSidecarList; -use types::{BlobSidecar, EthSpec, ForkName, MinimalEthSpec, SignedBlobSidecar}; +use types::{BlobSidecar, EthSpec, ForkName, MinimalEthSpec}; type E = MinimalEthSpec; @@ -29,15 +28,11 @@ async fn blob_sidecar_event_on_process_gossip_blob() { // build and process a gossip verified blob let kzg = harness.chain.kzg.as_ref().unwrap(); let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64); - let signed_sidecar = SignedBlobSidecar { - message: BlobSidecar::random_valid(&mut rng, kzg) - .map(Arc::new) - .unwrap(), - signature: Signature::empty(), - _phantom: PhantomData, - }; - let gossip_verified_blob = GossipVerifiedBlob::__assumed_valid(signed_sidecar); - let expected_sse_blobs = SseBlobSidecar::from_blob_sidecar(gossip_verified_blob.as_blob()); + let sidecar = BlobSidecar::random_valid(&mut rng, kzg) + .map(Arc::new) + .unwrap(); + let gossip_verified_blob = GossipVerifiedBlob::__assumed_valid(sidecar); + let expected_sse_blobs = SseBlobSidecar::from_blob_sidecar(gossip_verified_blob.deref()); let _ = harness .chain @@ -83,7 +78,7 @@ async fn blob_sidecar_event_on_process_rpc_blobs() { let _ = harness .chain - .process_rpc_blobs(blob_1.slot, blob_1.block_root, blobs) + .process_rpc_blobs(blob_1.slot(), blob_1.block_root(), blobs) .await .unwrap(); diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs index 6c2ccf596d3..b3513e248ad 100644 --- a/beacon_node/http_api/src/publish_blocks.rs +++ b/beacon_node/http_api/src/publish_blocks.rs @@ -86,8 +86,8 @@ pub async fn publish_block { let mut pubsub_messages = vec![PubsubMessage::BeaconBlock(block.clone())]; - if let Some(signed_blobs) = blobs_opt { - for (blob_index, blob) in signed_blobs.into_iter().enumerate() { + if let Some(blob_sidecars) = blobs_opt { + for (blob_index, blob) in blob_sidecars.into_iter().enumerate() { pubsub_messages.push(PubsubMessage::BlobSidecar(Box::new(( blob_index as u64, blob, diff --git a/beacon_node/http_api/tests/broadcast_validation_tests.rs b/beacon_node/http_api/tests/broadcast_validation_tests.rs index fe300ae5e1d..dcd8f7753f7 100644 --- a/beacon_node/http_api/tests/broadcast_validation_tests.rs +++ b/beacon_node/http_api/tests/broadcast_validation_tests.rs @@ -10,10 +10,7 @@ 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::{ - BlindedBlobSidecar, BlindedPayload, BlobSidecar, FullPayload, Hash256, MainnetEthSpec, - SignedSidecarList, Slot, -}; +use types::{BlindedPayload, FullPayload, Hash256, MainnetEthSpec, Slot}; use warp::Rejection; use warp_utils::reject::CustomBadRequest; @@ -1404,16 +1401,7 @@ pub async fn blinded_equivocation_full_pass() { fn into_signed_blinded_block_contents( block_contents_tuple: SignedBlockContentsTuple>, ) -> SignedBlockContents> { - let (block, maybe_blobs) = block_contents_tuple; - SignedBlockContents::new(block.into(), maybe_blobs.map(into_blinded_blob_sidecars)) -} - -fn into_blinded_blob_sidecars( - blobs: SignedSidecarList>, -) -> SignedSidecarList { - blobs - .into_iter() - .map(|blob| blob.into()) - .collect::>() - .into() + 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 327215209f2..6f1586bc87d 100644 --- a/beacon_node/http_api/tests/interactive_tests.rs +++ b/beacon_node/http_api/tests/interactive_tests.rs @@ -641,13 +641,9 @@ pub async fn proposer_boost_re_org_test( assert_eq!(block_c.parent_root(), block_b_root); } - // Sign blobs. - let block_c_signed_blobs = - block_c_blobs.map(|blobs| harness.sign_blobs(blobs, &state_b, proposer_index)); - // Applying block C should cause it to become head regardless (re-org or continuation). let block_root_c = harness - .process_block_result((block_c.clone(), block_c_signed_blobs)) + .process_block_result((block_c.clone(), block_c_blobs)) .await .unwrap() .into(); diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs index 0945aa74319..fe97e9bf9fc 100644 --- a/beacon_node/network/src/network_beacon_processor/tests.rs +++ b/beacon_node/network/src/network_beacon_processor/tests.rs @@ -1,4 +1,4 @@ -#![cfg(not(debug_assertions))] // Tests are too slow in debug. +// #![cfg(not(debug_assertions))] // Tests are too slow in debug. #![cfg(test)] use crate::network_beacon_processor::DELAYED_PEER_CACHE_SIZE; @@ -33,9 +33,9 @@ use std::time::Duration; use tokio::sync::mpsc; use types::blob_sidecar::FixedBlobSidecarList; use types::{ - Attestation, AttesterSlashing, Epoch, Hash256, MainnetEthSpec, ProposerSlashing, - SignedAggregateAndProof, SignedBeaconBlock, SignedBlobSidecarList, SignedVoluntaryExit, Slot, - SubnetId, + Attestation, AttesterSlashing, BlobSidecar, BlobSidecarList, Epoch, Hash256, MainnetEthSpec, + ProposerSlashing, Sidecar, SignedAggregateAndProof, SignedBeaconBlock, SignedVoluntaryExit, + Slot, SubnetId, }; type E = MainnetEthSpec; @@ -55,7 +55,7 @@ const STANDARD_TIMEOUT: Duration = Duration::from_secs(10); struct TestRig { chain: Arc>, next_block: Arc>, - next_blobs: Option>, + next_blobs: Option>, attestations: Vec<(Attestation, SubnetId)>, next_block_attestations: Vec<(Attestation, SubnetId)>, next_block_aggregate_attestations: Vec>, @@ -244,11 +244,24 @@ impl TestRig { ); assert!(!beacon_processor.is_err()); - + 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(), + ) + } else { + None + }; Self { chain, - next_block: Arc::new(next_block_tuple.0), - next_blobs: next_block_tuple.1, + next_block: Arc::new(block), + next_blobs: blob_sidecars, attestations, next_block_attestations, next_block_aggregate_attestations, @@ -293,7 +306,7 @@ impl TestRig { junk_message_id(), junk_peer_id(), Client::default(), - blob.message.index, + blob.index, blob.clone(), Duration::from_secs(0), ) @@ -328,12 +341,8 @@ 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.message)) - .collect::>(), - ); + let blobs = + FixedBlobSidecarList::from(blobs.into_iter().map(|b| Some(b)).collect::>()); self.network_beacon_processor .send_rpc_blobs( self.next_block.canonical_root(), diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs index bd1e72ee18d..edb2a7172ad 100644 --- a/beacon_node/network/src/sync/block_lookups/tests.rs +++ b/beacon_node/network/src/sync/block_lookups/tests.rs @@ -213,10 +213,8 @@ impl TestRig { ) -> (SignedBeaconBlock, Vec>) { let (mut block, mut blobs) = self.rand_block_and_blobs(fork_name, num_blobs); *block.message_mut().parent_root_mut() = parent_root; - let block_root = block.canonical_root(); blobs.iter_mut().for_each(|blob| { - blob.block_parent_root = parent_root; - blob.block_root = block_root; + blob.signed_block_header = block.signed_block_header(); }); (block, blobs) } @@ -1293,7 +1291,7 @@ mod deneb_only { let child_blob = blobs.first().cloned().unwrap(); let parent_root = block_root; - let child_root = child_blob.block_root; + let child_root = child_blob.block_root(); block_root = child_root; let mut blobs = FixedBlobSidecarList::default(); diff --git a/common/eth2/src/types.rs b/common/eth2/src/types.rs index c51e5867f19..50d9e02ea6e 100644 --- a/common/eth2/src/types.rs +++ b/common/eth2/src/types.rs @@ -1395,7 +1395,6 @@ pub enum ForkVersionedBeaconBlockType { mod tests { use super::*; use ssz::Encode; - use std::sync::Arc; #[test] fn query_vec() { @@ -1458,12 +1457,9 @@ mod tests { 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 blobs = BlobsList::::from(vec![Blob::::default()]); + let kzg_proofs = KzgProofs::::from(vec![KzgProof::empty()]); + let signed_block_contents = SignedBlockContents::new(block, Some((kzg_proofs, blobs))); let decoded: SignedBlockContents> = SignedBlockContents::from_ssz_bytes(&signed_block_contents.as_ssz_bytes(), &spec) @@ -1487,17 +1483,12 @@ mod tests { 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 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::BlindedBlock(_))); + assert!(matches!(decoded, SignedBlockContents::Block(_))); } } @@ -1836,18 +1827,11 @@ impl SignedBlockContents> { } } -// 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 SignedBlockContents { + pub fn clone_as_blinded(&self) -> SignedBlindedBlockContents { + SignedBlockContents::new(self.signed_block().clone_as_blinded(), None) + } +} impl> TryFrom> for SignedBlockContents diff --git a/consensus/types/src/chain_spec.rs b/consensus/types/src/chain_spec.rs index c6592d7012b..784d98c1397 100644 --- a/consensus/types/src/chain_spec.rs +++ b/consensus/types/src/chain_spec.rs @@ -1411,7 +1411,6 @@ mod tests { test_domain(Domain::BeaconProposer, spec.domain_beacon_proposer, &spec); test_domain(Domain::BeaconAttester, spec.domain_beacon_attester, &spec); - test_domain(Domain::BlobSidecar, spec.domain_blob_sidecar, &spec); test_domain(Domain::Randao, spec.domain_randao, &spec); test_domain(Domain::Deposit, spec.domain_deposit, &spec); test_domain(Domain::VoluntaryExit, spec.domain_voluntary_exit, &spec); @@ -1436,8 +1435,6 @@ mod tests { spec.domain_bls_to_execution_change, &spec, ); - - test_domain(Domain::BlobSidecar, spec.domain_blob_sidecar, &spec); } fn apply_bit_mask(domain_bytes: [u8; 4], spec: &ChainSpec) -> u32 {