From e3ee0c6cceb22db9684a8e8bef5667f0e4e369f1 Mon Sep 17 00:00:00 2001 From: realbigsean Date: Fri, 14 Jul 2023 17:29:41 -0400 Subject: [PATCH] cargo fmt --- .../beacon_chain/src/block_verification.rs | 8 ++---- .../src/block_verification_types.rs | 6 ++--- .../src/data_availability_checker.rs | 7 +++-- .../overflow_lru_cache.rs | 6 ++--- beacon_node/beacon_chain/src/test_utils.rs | 8 ++---- .../tests/attestation_production.rs | 3 ++- .../beacon_chain/tests/block_verification.rs | 27 ++++++++++++++----- .../src/network_beacon_processor/mod.rs | 20 +++----------- .../network_beacon_processor/sync_methods.rs | 7 ++--- .../src/network_beacon_processor/tests.rs | 18 +++++++------ beacon_node/network/src/router.rs | 16 ++++------- beacon_node/network/src/service/tests.rs | 2 +- .../src/sync/block_lookups/delayed_lookup.rs | 6 ++--- .../sync/block_lookups/single_block_lookup.rs | 17 +++++++----- .../src/sync/block_sidecar_coupling.rs | 2 +- .../network/src/sync/range_sync/range.rs | 6 ++--- consensus/fork_choice/tests/tests.rs | 8 ++++-- 17 files changed, 83 insertions(+), 84 deletions(-) diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs index dfe388417f..c9e0ee4c9d 100644 --- a/beacon_node/beacon_chain/src/block_verification.rs +++ b/beacon_node/beacon_chain/src/block_verification.rs @@ -1161,12 +1161,8 @@ impl IntoExecutionPendingBlock for Arc &SignedBeaconBlock { diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs index a152b757df..d88275b18a 100644 --- a/beacon_node/beacon_chain/src/block_verification_types.rs +++ b/beacon_node/beacon_chain/src/block_verification_types.rs @@ -1,6 +1,7 @@ use crate::blob_verification::GossipVerifiedBlobList; use crate::data_availability_checker::AvailabilityCheckError; pub use crate::data_availability_checker::{AvailableBlock, MaybeAvailableBlock}; +use crate::eth1_finalization_cache::Eth1FinalizationData; use crate::{data_availability_checker, GossipVerifiedBlock, PayloadVerificationOutcome}; use derivative::Derivative; use ssz_derive::{Decode, Encode}; @@ -14,7 +15,6 @@ use types::{ BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256, SignedBeaconBlock, SignedBeaconBlockHeader, Slot, }; -use crate::eth1_finalization_cache::Eth1FinalizationData; #[derive(Debug, Clone, Derivative)] #[derivative(Hash(bound = "E: EthSpec"))] @@ -44,7 +44,7 @@ impl RpcBlock { blobs: Option>, ) -> Result { if let Some(blobs) = blobs.as_ref() { - data_availability_checker::consistency_checks( &block, blobs)?; + data_availability_checker::consistency_checks(&block, blobs)?; } let inner = match blobs { Some(blobs) => RpcBlockInner::BlockAndBlobs(block, blobs), @@ -401,4 +401,4 @@ impl AsBlock for RpcBlock { fn into_rpc_block(self) -> RpcBlock { self } -} \ No newline at end of file +} diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs index eb33f64e91..d4c4d3c3d4 100644 --- a/beacon_node/beacon_chain/src/data_availability_checker.rs +++ b/beacon_node/beacon_chain/src/data_availability_checker.rs @@ -317,7 +317,7 @@ pub fn make_available( ) -> Result, AvailabilityCheckError> { let blobs = VariableList::new(blobs.into_iter().map(|blob| blob.to_blob()).collect())?; - consistency_checks( &block, &blobs)?; + consistency_checks(&block, &blobs)?; Ok(AvailableBlock { block, @@ -347,7 +347,10 @@ pub fn consistency_checks( return Ok(()); } - let block_root = blobs.first().map(|blob|blob.block_root).unwrap_or(block.canonical_root()); + let block_root = blobs + .first() + .map(|blob| blob.block_root) + .unwrap_or(block.canonical_root()); for (index, (block_commitment, blob)) in block_kzg_commitments.iter().zip(blobs.iter()).enumerate() { 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 0b40df73a6..014fb4597b 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 @@ -540,8 +540,7 @@ impl OverflowLRUCache { import_data, payload_verification_outcome, } = executed_block; - let available_block = - make_available(block, vec![])?; + let available_block = make_available(block, vec![])?; return Ok(Availability::Available(Box::new( AvailableExecutedBlock::new( available_block, @@ -591,8 +590,7 @@ impl OverflowLRUCache { return Ok(Availability::MissingComponents(import_data.block_root)) }; - let available_block = - make_available(block, verified_blobs)?; + let available_block = make_available(block, verified_blobs)?; Ok(Availability::Available(Box::new( AvailableExecutedBlock::new( available_block, diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs index b2cea41cb4..ae5f87fe83 100644 --- a/beacon_node/beacon_chain/src/test_utils.rs +++ b/beacon_node/beacon_chain/src/test_utils.rs @@ -700,7 +700,7 @@ where let block = self.chain.get_blinded_block(block_root).unwrap().unwrap(); let full_block = self.chain.store.make_full_block(block_root, block).unwrap(); let blobs = self.chain.get_blobs(block_root).unwrap(); - RpcBlock::new( Arc::new(full_block), blobs).unwrap() + RpcBlock::new(Arc::new(full_block), blobs).unwrap() } pub fn get_all_validators(&self) -> Vec { @@ -1985,11 +1985,7 @@ where .process_block( slot, block.canonical_root(), - RpcBlock::new( - Arc::new(block.clone()), - blobs_without_signatures.clone(), - ) - .unwrap(), + RpcBlock::new(Arc::new(block.clone()), blobs_without_signatures.clone()).unwrap(), ) .await?; Ok((block_hash, (block, blobs), new_state)) diff --git a/beacon_node/beacon_chain/tests/attestation_production.rs b/beacon_node/beacon_chain/tests/attestation_production.rs index db3ddf3bf0..907e7a40bb 100644 --- a/beacon_node/beacon_chain/tests/attestation_production.rs +++ b/beacon_node/beacon_chain/tests/attestation_production.rs @@ -133,7 +133,8 @@ async fn produces_attestations() { assert_eq!(data.target.epoch, state.current_epoch(), "bad target epoch"); assert_eq!(data.target.root, target_root, "bad target root"); - let rpc_block = RpcBlock::::new(Arc::new(block.clone()), blobs.clone()).unwrap(); + let rpc_block = + RpcBlock::::new(Arc::new(block.clone()), blobs.clone()).unwrap(); let beacon_chain::data_availability_checker::MaybeAvailableBlock::Available(available_block) = chain .data_availability_checker .check_rpc_block_availability(rpc_block) diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs index 852e40834c..102707a389 100644 --- a/beacon_node/beacon_chain/tests/block_verification.rs +++ b/beacon_node/beacon_chain/tests/block_verification.rs @@ -158,7 +158,9 @@ fn chain_segment_blocks( chain_segment .iter() .zip(blobs.into_iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect() } @@ -408,7 +410,9 @@ async fn assert_invalid_signature( let blocks: Vec> = snapshots .iter() .zip(chain_segment_blobs.iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect(); // Ensure the block will be rejected if imported in a chain segment. @@ -433,7 +437,9 @@ async fn assert_invalid_signature( .iter() .take(block_index) .zip(chain_segment_blobs.iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect(); // We don't care if this fails, we just call this to ensure that all prior blocks have been // imported prior to this test. @@ -450,7 +456,8 @@ async fn assert_invalid_signature( RpcBlock::new( snapshots[block_index].beacon_block.clone(), chain_segment_blobs[block_index].clone(), - ).unwrap(), + ) + .unwrap(), NotifyExecutionLayer::Yes, || Ok(()), ) @@ -501,7 +508,9 @@ async fn invalid_signature_gossip_block() { .iter() .take(block_index) .zip(chain_segment_blobs.iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect(); harness .chain @@ -546,7 +555,9 @@ async fn invalid_signature_block_proposal() { let blocks: Vec> = snapshots .iter() .zip(chain_segment_blobs.iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect::>(); // Ensure the block will be rejected if imported in a chain segment. assert!( @@ -757,7 +768,9 @@ async fn invalid_signature_deposit() { let blocks: Vec> = snapshots .iter() .zip(chain_segment_blobs.iter()) - .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()) + .map(|(snapshot, blobs)| { + RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap() + }) .collect(); assert!( !matches!( diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs index 166417ba93..1d2d62bc1f 100644 --- a/beacon_node/network/src/network_beacon_processor/mod.rs +++ b/beacon_node/network/src/network_beacon_processor/mod.rs @@ -13,6 +13,7 @@ use beacon_processor::{ MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN, }; use environment::null_logger; +use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest}; use lighthouse_network::{ rpc::{BlocksByRangeRequest, BlocksByRootRequest, LightClientBootstrapRequest, StatusMessage}, Client, MessageId, NetworkGlobals, PeerId, PeerRequestId, @@ -26,7 +27,6 @@ use store::MemoryStore; use task_executor::test_utils::TestRuntime; use task_executor::TaskExecutor; use tokio::sync::mpsc::{self, error::TrySendError}; -use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest}; use types::*; pub use sync_methods::ChainSegmentProcessId; @@ -229,9 +229,7 @@ impl NetworkBeaconProcessor { }) } - pub fn send_banana(){ - - } + pub fn send_banana() {} /// Create a new `Work` event for some sync committee signature. pub fn send_gossip_sync_signature( @@ -563,12 +561,7 @@ impl NetworkBeaconProcessor { ) -> Result<(), Error> { let processor = self.clone(); let process_fn = move |send_idle_on_drop| { - processor.handle_blobs_by_range_request( - send_idle_on_drop, - peer_id, - request_id, - request, - ) + processor.handle_blobs_by_range_request(send_idle_on_drop, peer_id, request_id, request) }; self.try_send(BeaconWorkEvent { @@ -586,12 +579,7 @@ impl NetworkBeaconProcessor { ) -> Result<(), Error> { let processor = self.clone(); let process_fn = move |send_idle_on_drop| { - processor.handle_blobs_by_root_request( - send_idle_on_drop, - peer_id, - request_id, - request, - ) + processor.handle_blobs_by_root_request(send_idle_on_drop, peer_id, request_id, request) }; self.try_send(BeaconWorkEvent { diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs index 3a09373c56..b21bc6abde 100644 --- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs +++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs @@ -6,9 +6,9 @@ use crate::sync::{ manager::{BlockProcessType, SyncMessage}, ChainId, }; -use beacon_chain::data_availability_checker::MaybeAvailableBlock; use beacon_chain::block_verification_types::{AsBlock, RpcBlock}; use beacon_chain::data_availability_checker::AvailabilityCheckError; +use beacon_chain::data_availability_checker::MaybeAvailableBlock; use beacon_chain::{ observed_block_producers::Error as ObserveError, validator_monitor::get_block_delay_ms, AvailabilityProcessingStatus, BeaconChainError, BeaconChainTypes, BlockError, @@ -270,7 +270,8 @@ impl NetworkBeaconProcessor { process_type: BlockProcessType, ) -> AsyncFn { let process_fn = async move { - self.clone().process_rpc_blobs(block_root, block, seen_timestamp, process_type) + self.clone() + .process_rpc_blobs(block_root, block, seen_timestamp, process_type) .await; }; Box::pin(process_fn) @@ -306,7 +307,7 @@ impl NetworkBeaconProcessor { }); } - pub fn send_delayed_lookup(&self, block_root: Hash256){ + pub fn send_delayed_lookup(&self, block_root: Hash256) { self.send_sync_message(SyncMessage::MissingGossipBlockComponentsDelayed(block_root)) } diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs index 39d3575d6e..2c37d177aa 100644 --- a/beacon_node/network/src/network_beacon_processor/tests.rs +++ b/beacon_node/network/src/network_beacon_processor/tests.rs @@ -336,14 +336,16 @@ impl TestRig { } pub fn enqueue_blobs_by_range_request(&self, count: u64) { - self.network_beacon_processor.send_blobs_by_range_request( - PeerId::random(), - (ConnectionId::new(42), SubstreamId::new(24)), - BlobsByRangeRequest { - start_slot: 0, - count, - }, - ).unwrap(); + self.network_beacon_processor + .send_blobs_by_range_request( + PeerId::random(), + (ConnectionId::new(42), SubstreamId::new(24)), + BlobsByRangeRequest { + start_slot: 0, + count, + }, + ) + .unwrap(); } pub fn enqueue_backfill_batch(&self) { diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs index 5a954d05a4..30a75a9105 100644 --- a/beacon_node/network/src/router.rs +++ b/beacon_node/network/src/router.rs @@ -209,18 +209,12 @@ impl Router { .send_blocks_by_roots_request(peer_id, request_id, request), ), Request::BlobsByRange(request) => self.handle_beacon_processor_send_result( - self.network_beacon_processor.send_blobs_by_range_request( - peer_id, - request_id, - request, - ), + self.network_beacon_processor + .send_blobs_by_range_request(peer_id, request_id, request), ), Request::BlobsByRoot(request) => self.handle_beacon_processor_send_result( - self.network_beacon_processor.send_blobs_by_roots_request( - peer_id, - request_id, - request, - ), + self.network_beacon_processor + .send_blobs_by_roots_request(peer_id, request_id, request), ), Request::LightClientBootstrap(request) => self.handle_beacon_processor_send_result( self.network_beacon_processor @@ -311,7 +305,7 @@ impl Router { blob_index, signed_blob, timestamp_now(), - ) + ), ) } PubsubMessage::VoluntaryExit(exit) => { diff --git a/beacon_node/network/src/service/tests.rs b/beacon_node/network/src/service/tests.rs index 10110aa891..544c5dd9c7 100644 --- a/beacon_node/network/src/service/tests.rs +++ b/beacon_node/network/src/service/tests.rs @@ -3,6 +3,7 @@ mod tests { use crate::persisted_dht::load_dht; use crate::{NetworkConfig, NetworkService}; + use beacon_chain::test_utils::EphemeralHarnessType; use beacon_processor::{ BeaconProcessorSend, MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN, }; @@ -12,7 +13,6 @@ mod tests { use std::str::FromStr; use std::sync::Arc; use tokio::{runtime::Runtime, sync::mpsc}; - use beacon_chain::test_utils::EphemeralHarnessType; use types::MinimalEthSpec as E; type BeaconChainHarness = beacon_chain::test_utils::BeaconChainHarness>; diff --git a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs index c492470b4a..55e9e49db3 100644 --- a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs +++ b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs @@ -1,12 +1,12 @@ +use crate::network_beacon_processor::NetworkBeaconProcessor; use beacon_chain::{BeaconChain, BeaconChainTypes}; -use slog::{crit, }; +use slog::crit; use slot_clock::SlotClock; use std::sync::Arc; use tokio::sync::mpsc; use tokio::time::interval_at; use tokio::time::Instant; -use types::{ Hash256}; -use crate::network_beacon_processor::NetworkBeaconProcessor; +use types::Hash256; #[derive(Debug)] pub enum DelayedLookupMessage { diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs index 37b5ee0e76..90829905b8 100644 --- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs +++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs @@ -313,13 +313,16 @@ impl SingleBlockLookup>(); - let blobs = VariableList::from(filtered); - RpcBlock::new(block.clone(), Some(blobs)).ok() - }) + //TODO(sean) figure out how to properly deal with a consistency error here, + // should we downscore the peer sending blobs? + let blobs = std::mem::take(downloaded_blobs); + let filtered = blobs + .into_iter() + .filter_map(|b| b.clone()) + .collect::>(); + let blobs = VariableList::from(filtered); + RpcBlock::new(block.clone(), Some(blobs)).ok() + }) } else { None } diff --git a/beacon_node/network/src/sync/block_sidecar_coupling.rs b/beacon_node/network/src/sync/block_sidecar_coupling.rs index b25dcdf334..fce7a2e30d 100644 --- a/beacon_node/network/src/sync/block_sidecar_coupling.rs +++ b/beacon_node/network/src/sync/block_sidecar_coupling.rs @@ -1,5 +1,5 @@ use beacon_chain::block_verification_types::RpcBlock; -use ssz_types::{VariableList}; +use ssz_types::VariableList; use std::{collections::VecDeque, sync::Arc}; use types::{BlobSidecar, EthSpec, SignedBeaconBlock}; diff --git a/beacon_node/network/src/sync/range_sync/range.rs b/beacon_node/network/src/sync/range_sync/range.rs index f69a30b3ee..277606e438 100644 --- a/beacon_node/network/src/sync/range_sync/range.rs +++ b/beacon_node/network/src/sync/range_sync/range.rs @@ -387,18 +387,18 @@ mod tests { use beacon_chain::builder::Witness; use beacon_chain::eth1_chain::CachingEth1Backend; use beacon_chain::parking_lot::RwLock; + use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType}; use beacon_chain::EngineState; use beacon_processor::WorkEvent as BeaconWorkEvent; use lighthouse_network::rpc::BlocksByRangeRequest; use lighthouse_network::Request; use lighthouse_network::{rpc::StatusMessage, NetworkGlobals}; use slog::{o, Drain}; - use tokio::sync::mpsc; - use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType}; - use slot_clock::{TestingSlotClock, }; + use slot_clock::TestingSlotClock; use std::collections::HashSet; use std::sync::Arc; use store::MemoryStore; + use tokio::sync::mpsc; use types::{Hash256, MinimalEthSpec as E}; #[derive(Debug)] diff --git a/consensus/fork_choice/tests/tests.rs b/consensus/fork_choice/tests/tests.rs index bba7ccdbe6..b4981a3eea 100644 --- a/consensus/fork_choice/tests/tests.rs +++ b/consensus/fork_choice/tests/tests.rs @@ -4,6 +4,7 @@ use std::fmt; use std::sync::Mutex; use std::time::Duration; +use beacon_chain::block_verification_types::RpcBlock; use beacon_chain::test_utils::{ AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType, }; @@ -11,7 +12,6 @@ use beacon_chain::{ BeaconChain, BeaconChainError, BeaconForkChoiceStore, ChainConfig, ForkChoiceError, StateSkipConfig, WhenSlotSkipped, }; -use beacon_chain::block_verification_types::RpcBlock; use fork_choice::{ ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus, QueuedAttestation, }; @@ -201,7 +201,11 @@ impl ForkChoiceTest { if !predicate(block.0.message(), &state) { break; } - if let Ok(block_hash) = self.harness.process_block_result(RpcBlock::new(block.0, block.1).unwrap()).await { + if let Ok(block_hash) = self + .harness + .process_block_result(RpcBlock::new(block.0, block.1).unwrap()) + .await + { self.harness.attest_block( &state, block.0.state_root(),