gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-05-30 20:57:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix failing tests (#4423)

Browse Source 
* Get tests passing

* Get benchmarks compiling

* Fix EF withdrawals test

* Remove unused deps

* Fix tree_hash panic in tests

* Fix slasher compilation

* Fix ssz_generic test

* Get more tests passing

* Fix EF tests for real

* Fix local testnet scripts
This commit is contained in:
Michael Sproul
2023-06-27 15:04:39 +10:00
committed by GitHub
parent ca412ab3f0
commit 88e30b6dcf
26 changed files with 404 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
beacon_node/beacon_chain/src/beacon_chain.rs
View File

@@ -154,6 +154,7 @@ pub const INVALID_FINALIZED_MERGE_TRANSITION_BLOCK_SHUTDOWN_REASON: &str =
"Finalized merge transition block is invalid.";
/// Defines the behaviour when a block/block-root for a skipped slot is requested.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WhenSlotSkipped {
/// If the slot is a skip slot, return `None`.
///
@@ -749,10 +750,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
) -> Result<Option<SignedBlindedBeaconBlock<T::EthSpec>>, Error> {
let root = self.block_root_at_slot(request_slot, skips)?;
// Only hint the slot if expect a block at this exact slot.
let slot_hint = match skips {
WhenSlotSkipped::Prev => None,
WhenSlotSkipped::None => Some(request_slot),
};
if let Some(block_root) = root {
Ok(self
.store
.get_blinded_block(&block_root, Some(request_slot))?)
Ok(self.store.get_blinded_block(&block_root, slot_hint)?)
} else {
Ok(None)
}
@@ -5530,29 +5535,27 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
///
/// This could be a very expensive operation and should only be done in testing/analysis
/// activities.
///
/// This dump function previously used a backwards iterator but has been swapped to a forwards
/// iterator as it allows for MUCH better caching and rebasing. Memory usage of some tests went
/// from 5GB per test to 90MB.
#[allow(clippy::type_complexity)]
pub fn chain_dump(
&self,
) -> Result<Vec<BeaconSnapshot<T::EthSpec, BlindedPayload<T::EthSpec>>>, Error> {
let mut dump = vec![];
let mut last_slot = {
let head = self.canonical_head.cached_head();
BeaconSnapshot {
beacon_block: Arc::new(head.snapshot.beacon_block.clone_as_blinded()),
beacon_block_root: head.snapshot.beacon_block_root,
beacon_state: head.snapshot.beacon_state.clone(),
}
};
dump.push(last_slot.clone());
loop {
let beacon_block_root = last_slot.beacon_block.parent_root();
if beacon_block_root == Hash256::zero() {
break; // Genesis has been reached.
let mut prev_block_root = None;
let mut prev_beacon_state = None;
for res in self.forwards_iter_block_roots(Slot::new(0))? {
let (beacon_block_root, _) = res?;
// Do not include snapshots at skipped slots.
if Some(beacon_block_root) == prev_block_root {
continue;
}
prev_block_root = Some(beacon_block_root);
let beacon_block = self
.store
@@ -5561,25 +5564,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
Error::DBInconsistent(format!("Missing block {}", beacon_block_root))
})?;
let beacon_state_root = beacon_block.state_root();
let beacon_state = self
let mut beacon_state = self
.store
.get_state(&beacon_state_root, Some(beacon_block.slot()))?
.ok_or_else(|| {
Error::DBInconsistent(format!("Missing state {:?}", beacon_state_root))
})?;
let slot = BeaconSnapshot {
// This beacon state might come from the freezer DB, which means it could have pending
// updates or lots of untethered memory. We rebase it on the previous state in order to
// address this.
beacon_state.apply_pending_mutations()?;
if let Some(prev) = prev_beacon_state {
beacon_state.rebase_on(&prev, &self.spec)?;
}
beacon_state.build_all_caches(&self.spec)?;
prev_beacon_state = Some(beacon_state.clone());
let snapshot = BeaconSnapshot {
beacon_block: Arc::new(beacon_block),
beacon_block_root,
beacon_state,
};
dump.push(slot.clone());
last_slot = slot;
dump.push(snapshot);
}
dump.reverse();
Ok(dump)
}

22
beacon_node/beacon_chain/src/builder.rs
View File

@@ -328,21 +328,30 @@ where
.ok_or("set_genesis_state requires a store")?;
let beacon_block = genesis_block(&mut beacon_state, &self.spec)?;
let blinded_block = beacon_block.clone_as_blinded();
let beacon_state_root = beacon_block.message().state_root();
let beacon_block_root = beacon_block.canonical_root();
let (blinded_block, payload) = beacon_block.into();
beacon_state
.build_all_caches(&self.spec)
.map_err(|e| format!("Failed to build genesis state caches: {:?}", e))?;
let beacon_state_root = beacon_block.message().state_root();
let beacon_block_root = beacon_block.canonical_root();
store
.update_finalized_state(beacon_state_root, beacon_block_root, beacon_state.clone())
.map_err(|e| format!("Failed to set genesis state as finalized state: {:?}", e))?;
store
.put_state(&beacon_state_root, &beacon_state)
.map_err(|e| format!("Failed to store genesis state: {:?}", e))?;
// Store the genesis block's execution payload (if any) in the hot database.
if let Some(execution_payload) = &payload {
store
.put_execution_payload(&beacon_block_root, execution_payload)
.map_err(|e| format!("Failed to store genesis execution payload: {e:?}"))?;
// FIXME(sproul): store it again under the 0x00 root?
}
// Store the genesis block in the cold database.
store
.put_cold_blinded_block(&beacon_block_root, &blinded_block)
.map_err(|e| format!("Failed to store genesis block: {:?}", e))?;
@@ -357,6 +366,11 @@ where
)
})?;
// Reconstruct full genesis block.
let beacon_block = blinded_block
.try_into_full_block(payload)
.ok_or("Unable to reconstruct genesis block with payload")?;
self.genesis_state_root = Some(beacon_state_root);
self.genesis_block_root = Some(beacon_block_root);
self.genesis_time = Some(beacon_state.genesis_time());

26
beacon_node/beacon_chain/tests/store_tests.rs
View File

@@ -2,7 +2,6 @@
use beacon_chain::attestation_verification::Error as AttnError;
use beacon_chain::builder::BeaconChainBuilder;
use beacon_chain::schema_change::migrate_schema;
use beacon_chain::test_utils::{
test_spec, AttestationStrategy, BeaconChainHarness, BlockStrategy, DiskHarnessType,
};
@@ -22,7 +21,6 @@ use std::collections::HashSet;
use std::convert::TryInto;
use std::sync::Arc;
use std::time::Duration;
use store::metadata::{SchemaVersion, CURRENT_SCHEMA_VERSION};
use store::{
iter::{BlockRootsIterator, StateRootsIterator},
HotColdDB, LevelDB, StoreConfig,
@@ -398,10 +396,9 @@ async fn forwards_iter_block_and_state_roots_until() {
check_finalization(&harness, num_blocks_produced);
check_split_slot(&harness, store.clone());
// The last restore point slot is the point at which the hybrid forwards iterator behaviour
// changes.
let last_restore_point_slot = store.get_latest_restore_point_slot();
assert!(last_restore_point_slot > 0);
// The split slot is the point at which the hybrid forwards iterator behaviour changes.
let split_slot = store.get_split_slot();
assert!(split_slot > 0);
let chain = &harness.chain;
let head_state = harness.get_current_state();
@@ -425,15 +422,12 @@ async fn forwards_iter_block_and_state_roots_until() {
}
};
let split_slot = store.get_split_slot();
assert!(split_slot > last_restore_point_slot);
test_range(Slot::new(0), last_restore_point_slot);
test_range(last_restore_point_slot, last_restore_point_slot);
test_range(last_restore_point_slot - 1, last_restore_point_slot);
test_range(Slot::new(0), last_restore_point_slot - 1);
test_range(Slot::new(0), split_slot);
test_range(last_restore_point_slot - 1, split_slot);
test_range(split_slot, split_slot);
test_range(split_slot - 1, split_slot);
test_range(Slot::new(0), split_slot - 1);
test_range(Slot::new(0), split_slot);
test_range(split_slot - 1, split_slot);
test_range(Slot::new(0), head_state.slot());
}
@@ -2496,6 +2490,9 @@ async fn revert_minority_fork_on_resume() {
// version is correct. This is the easiest schema test to write without historic versions of
// Lighthouse on-hand, but has the disadvantage that the min version needs to be adjusted manually
// as old downgrades are deprecated.
/* FIXME(sproul): broken until DB migration is implemented
use beacon_chain::schema_change::migrate_schema;
use store::metadata::{SchemaVersion, CURRENT_SCHEMA_VERSION};
#[tokio::test]
async fn schema_downgrade_to_min_version() {
let num_blocks_produced = E::slots_per_epoch() * 4;
@@ -2576,6 +2573,7 @@ async fn schema_downgrade_to_min_version() {
)
.expect_err("should not downgrade below minimum version");
}
*/
/// Checks that two chains are the same, for the purpose of these tests.
///

8
beacon_node/beacon_chain/tests/tests.rs
View File

@@ -10,9 +10,7 @@ use beacon_chain::{
};
use lazy_static::lazy_static;
use operation_pool::PersistedOperationPool;
use state_processing::{
per_slot_processing, per_slot_processing::Error as SlotProcessingError, EpochProcessingError,
};
use state_processing::{per_slot_processing, per_slot_processing::Error as SlotProcessingError};
use types::{
BeaconState, BeaconStateError, EthSpec, Hash256, Keypair, MinimalEthSpec, RelativeEpoch, Slot,
};
@@ -55,9 +53,7 @@ fn massive_skips() {
assert!(state.slot() > 1, "the state should skip at least one slot");
assert_eq!(
error,
SlotProcessingError::EpochProcessingError(EpochProcessingError::BeaconStateError(
BeaconStateError::InsufficientValidators
)),
SlotProcessingError::BeaconStateError(BeaconStateError::InsufficientValidators),
"should return error indicating that validators have been slashed out"
)
}