cerc-io/lighthouse
10
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Small Improvements (#4980)

Browse Source 
* initial changes

* use arc<blobsidecar> in vector

* Utilize new pattern for KzgVerifiedBlob

* fmt

* Update beacon_node/beacon_chain/src/blob_verification.rs

Co-authored-by: realbigsean <seananderson33@GMAIL.com>

* forgot to save..

* lint

* fmt.. again

---------

Co-authored-by: realbigsean <seananderson33@GMAIL.com>
This commit is contained in:
ethDreamer 2023-12-06 14:51:40 -06:00 committed by GitHub
parent 31044402ee
commit 52117f43ba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 36 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
beacon_node/beacon_chain/src/blob_verification.rs
View File

@ -276,6 +276,10 @@ impl<T: EthSpec> Ord for KzgVerifiedBlob<T> {
} }
impl<T: EthSpec> KzgVerifiedBlob<T> { impl<T: EthSpec> KzgVerifiedBlob<T> {
pub fn new(blob: Arc<BlobSidecar<T>>, kzg: &Kzg) -> Result<Self, KzgError> {
verify_kzg_for_blob(blob, kzg)
}
pub fn to_blob(self) -> Arc<BlobSidecar<T>> { pub fn to_blob(self) -> Arc<BlobSidecar<T>> {
self.blob self.blob
} }
@ -289,14 +293,12 @@ impl<T: EthSpec> KzgVerifiedBlob<T> {
pub fn blob_index(&self) -> u64 { pub fn blob_index(&self) -> u64 {
self.blob.index self.blob.index
} }
} /// Construct a `KzgVerifiedBlob` that is assumed to be valid.
///
#[cfg(test)] /// This should ONLY be used for testing.
impl<T: EthSpec> KzgVerifiedBlob<T> { #[cfg(test)]
pub fn new(blob: BlobSidecar<T>) -> Self { pub fn __assumed_valid(blob: Arc<BlobSidecar<T>>) -> Self {
Self { Self { blob }
blob: Arc::new(blob),
}
} }
} }
@ -599,7 +601,7 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes>(
.as_ref() .as_ref()
.ok_or(GossipBlobError::KzgNotInitialized)?; .ok_or(GossipBlobError::KzgNotInitialized)?;
let kzg_verified_blob = let kzg_verified_blob =
verify_kzg_for_blob(blob_sidecar, kzg).map_err(GossipBlobError::KzgError)?; KzgVerifiedBlob::new(blob_sidecar, kzg).map_err(GossipBlobError::KzgError)?;
Ok(GossipVerifiedBlob { Ok(GossipVerifiedBlob {
block_root, block_root,

9
beacon_node/beacon_chain/src/data_availability_checker.rs
View File

@ -1,4 +1,4 @@
use crate::blob_verification::{verify_kzg_for_blob, verify_kzg_for_blob_list, GossipVerifiedBlob}; use crate::blob_verification::{verify_kzg_for_blob_list, GossipVerifiedBlob, KzgVerifiedBlob};
use crate::block_verification_types::{ use crate::block_verification_types::{
AvailabilityPendingExecutedBlock, AvailableExecutedBlock, RpcBlock, AvailabilityPendingExecutedBlock, AvailableExecutedBlock, RpcBlock,
}; };
@ -199,10 +199,9 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
) -> Result<Availability<T::EthSpec>, AvailabilityCheckError> { ) -> Result<Availability<T::EthSpec>, AvailabilityCheckError> {
let mut verified_blobs = vec![]; let mut verified_blobs = vec![];
if let Some(kzg) = self.kzg.as_ref() { if let Some(kzg) = self.kzg.as_ref() {
for blob in blobs.iter().flatten() { for blob in Vec::from(blobs).into_iter().flatten() {
verified_blobs.push( verified_blobs
verify_kzg_for_blob(blob.clone(), kzg).map_err(AvailabilityCheckError::Kzg)?, .push(KzgVerifiedBlob::new(blob, kzg).map_err(AvailabilityCheckError::Kzg)?);
);
} }
} else { } else {
return Err(AvailabilityCheckError::KzgNotInitialized); return Err(AvailabilityCheckError::KzgNotInitialized);

47
beacon_node/beacon_chain/src/data_availability_checker/availability_view.rs
View File

@ -278,8 +278,8 @@ pub mod tests {
type Setup<E> = ( type Setup<E> = (
SignedBeaconBlock<E>, SignedBeaconBlock<E>,
FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
); );
pub fn pre_setup() -> Setup<E> { pub fn pre_setup() -> Setup<E> {
@ -290,20 +290,20 @@ pub mod tests {
for blob in blobs_vec { for blob in blobs_vec {
if let Some(b) = blobs.get_mut(blob.index as usize) { if let Some(b) = blobs.get_mut(blob.index as usize) {
*b = Some(blob); *b = Some(Arc::new(blob));
} }
} }
let mut invalid_blobs: FixedVector< let mut invalid_blobs: FixedVector<
Option<BlobSidecar<E>>, Option<Arc<BlobSidecar<E>>>,
<E as EthSpec>::MaxBlobsPerBlock, <E as EthSpec>::MaxBlobsPerBlock,
> = FixedVector::default(); > = FixedVector::default();
for (index, blob) in blobs.iter().enumerate() { for (index, blob) in blobs.iter().enumerate() {
let mut invalid_blob_opt = blob.clone(); if let Some(invalid_blob) = blob {
if let Some(invalid_blob) = invalid_blob_opt.as_mut() { let mut blob_copy = invalid_blob.as_ref().clone();
invalid_blob.kzg_commitment = KzgCommitment::random_for_test(&mut rng); blob_copy.kzg_commitment = KzgCommitment::random_for_test(&mut rng);
*invalid_blobs.get_mut(index).unwrap() = Some(Arc::new(blob_copy));
} }
*invalid_blobs.get_mut(index).unwrap() = invalid_blob_opt;
} }
(block, blobs, invalid_blobs) (block, blobs, invalid_blobs)
@ -317,8 +317,8 @@ pub mod tests {
pub fn setup_processing_components( pub fn setup_processing_components(
block: SignedBeaconBlock<E>, block: SignedBeaconBlock<E>,
valid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
invalid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
) -> ProcessingViewSetup<E> { ) -> ProcessingViewSetup<E> {
let commitments = block let commitments = block
.message() .message()
@ -349,8 +349,8 @@ pub mod tests {
pub fn setup_pending_components( pub fn setup_pending_components(
block: SignedBeaconBlock<E>, block: SignedBeaconBlock<E>,
valid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
invalid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
) -> PendingComponentsSetup<E> { ) -> PendingComponentsSetup<E> {
let blobs = FixedVector::from( let blobs = FixedVector::from(
valid_blobs valid_blobs
@ -358,7 +358,7 @@ pub mod tests {
.map(|blob_opt| { .map(|blob_opt| {
blob_opt blob_opt
.as_ref() .as_ref()
.map(|blob| KzgVerifiedBlob::new(blob.clone())) .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
}) })
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
@ -368,7 +368,7 @@ pub mod tests {
.map(|blob_opt| { .map(|blob_opt| {
blob_opt blob_opt
.as_ref() .as_ref()
.map(|blob| KzgVerifiedBlob::new(blob.clone())) .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
}) })
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
@ -402,21 +402,12 @@ pub mod tests {
pub fn setup_child_components( pub fn setup_child_components(
block: SignedBeaconBlock<E>, block: SignedBeaconBlock<E>,
valid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
invalid_blobs: FixedVector<Option<BlobSidecar<E>>, <E as EthSpec>::MaxBlobsPerBlock>, invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
) -> ChildComponentsSetup<E> { ) -> ChildComponentsSetup<E> {
let blobs = FixedVector::from( let blobs = FixedVector::from(valid_blobs.into_iter().cloned().collect::<Vec<_>>());
valid_blobs let invalid_blobs =
.into_iter() FixedVector::from(invalid_blobs.into_iter().cloned().collect::<Vec<_>>());
.map(|blob_opt| blob_opt.clone().map(Arc::new))
.collect::<Vec<_>>(),
);
let invalid_blobs = FixedVector::from(
invalid_blobs
.into_iter()
.map(|blob_opt| blob_opt.clone().map(Arc::new))
.collect::<Vec<_>>(),
);
(Arc::new(block), blobs, invalid_blobs) (Arc::new(block), blobs, invalid_blobs)
} }

4
beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
View File

@ -738,7 +738,7 @@ impl ssz::Decode for OverflowKey {
mod test { mod test {
use super::*; use super::*;
use crate::{ use crate::{
blob_verification::{validate_blob_sidecar_for_gossip, GossipVerifiedBlob}, blob_verification::GossipVerifiedBlob,
block_verification::PayloadVerificationOutcome, block_verification::PayloadVerificationOutcome,
block_verification_types::{AsBlock, BlockImportData}, block_verification_types::{AsBlock, BlockImportData},
data_availability_checker::STATE_LRU_CAPACITY, data_availability_checker::STATE_LRU_CAPACITY,
@ -925,7 +925,7 @@ mod test {
.into_iter() .into_iter()
.map(|sidecar| { .map(|sidecar| {
let subnet = sidecar.index; let subnet = sidecar.index;
validate_blob_sidecar_for_gossip(sidecar, subnet, &harness.chain) GossipVerifiedBlob::new(sidecar, subnet, &harness.chain)
.expect("should validate blob") .expect("should validate blob")
}) })
.collect() .collect()