433 lines
13 KiB
Rust
433 lines
13 KiB
Rust
//! Tests for gossip verification of voluntary exits, propser slashings and attester slashings.
|
|
|
|
#![cfg(not(debug_assertions))]
|
|
|
|
use beacon_chain::{
|
|
observed_operations::ObservationOutcome,
|
|
test_utils::{
|
|
test_spec, AttestationStrategy, BeaconChainHarness, BlockStrategy, DiskHarnessType,
|
|
},
|
|
BeaconChainError,
|
|
};
|
|
use lazy_static::lazy_static;
|
|
use sloggers::{null::NullLoggerBuilder, Build};
|
|
use state_processing::per_block_processing::errors::{
|
|
AttesterSlashingInvalid, BlockOperationError, ExitInvalid, ProposerSlashingInvalid,
|
|
};
|
|
use std::sync::Arc;
|
|
use store::{LevelDB, StoreConfig};
|
|
use tempfile::{tempdir, TempDir};
|
|
use types::*;
|
|
|
|
pub const VALIDATOR_COUNT: usize = 24;
|
|
|
|
lazy_static! {
|
|
/// A cached set of keys.
|
|
static ref KEYPAIRS: Vec<Keypair> =
|
|
types::test_utils::generate_deterministic_keypairs(VALIDATOR_COUNT);
|
|
}
|
|
|
|
type E = MinimalEthSpec;
|
|
type TestHarness = BeaconChainHarness<DiskHarnessType<E>>;
|
|
type HotColdDB = store::HotColdDB<E, LevelDB<E>, LevelDB<E>>;
|
|
|
|
fn get_store(db_path: &TempDir) -> Arc<HotColdDB> {
|
|
let spec = test_spec::<E>();
|
|
let hot_path = db_path.path().join("hot_db");
|
|
let cold_path = db_path.path().join("cold_db");
|
|
let blobs_path = db_path.path().join("blobs_db");
|
|
let config = StoreConfig::default();
|
|
let log = NullLoggerBuilder.build().expect("logger should build");
|
|
HotColdDB::open(
|
|
&hot_path,
|
|
&cold_path,
|
|
&blobs_path,
|
|
|_, _, _| Ok(()),
|
|
config,
|
|
spec,
|
|
log,
|
|
)
|
|
.expect("disk store should initialize")
|
|
}
|
|
|
|
fn get_harness(store: Arc<HotColdDB>, validator_count: usize) -> TestHarness {
|
|
let harness = BeaconChainHarness::builder(MinimalEthSpec)
|
|
.default_spec()
|
|
.keypairs(KEYPAIRS[0..validator_count].to_vec())
|
|
.fresh_disk_store(store)
|
|
.mock_execution_layer()
|
|
.build();
|
|
harness.advance_slot();
|
|
harness
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn voluntary_exit() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
let spec = &harness.chain.spec.clone();
|
|
|
|
harness
|
|
.extend_chain(
|
|
(E::slots_per_epoch() * (spec.shard_committee_period + 1)) as usize,
|
|
BlockStrategy::OnCanonicalHead,
|
|
AttestationStrategy::AllValidators,
|
|
)
|
|
.await;
|
|
|
|
let validator_index1 = VALIDATOR_COUNT - 1;
|
|
let validator_index2 = VALIDATOR_COUNT - 2;
|
|
|
|
let exit1 = harness.make_voluntary_exit(
|
|
validator_index1 as u64,
|
|
Epoch::new(spec.shard_committee_period),
|
|
);
|
|
|
|
// First verification should show it to be fresh.
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_voluntary_exit_for_gossip(exit1.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
|
|
// Second should not.
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_voluntary_exit_for_gossip(exit1.clone()),
|
|
Ok(ObservationOutcome::AlreadyKnown)
|
|
));
|
|
|
|
// A different exit for the same validator should also be detected as a duplicate.
|
|
let exit2 = harness.make_voluntary_exit(
|
|
validator_index1 as u64,
|
|
Epoch::new(spec.shard_committee_period + 1),
|
|
);
|
|
assert!(matches!(
|
|
harness.chain.verify_voluntary_exit_for_gossip(exit2),
|
|
Ok(ObservationOutcome::AlreadyKnown)
|
|
));
|
|
|
|
// Exit for a different validator should be fine.
|
|
let exit3 = harness.make_voluntary_exit(
|
|
validator_index2 as u64,
|
|
Epoch::new(spec.shard_committee_period),
|
|
);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_voluntary_exit_for_gossip(exit3)
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn voluntary_exit_duplicate_in_state() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
let spec = &harness.chain.spec;
|
|
|
|
harness
|
|
.extend_chain(
|
|
(E::slots_per_epoch() * (spec.shard_committee_period + 1)) as usize,
|
|
BlockStrategy::OnCanonicalHead,
|
|
AttestationStrategy::AllValidators,
|
|
)
|
|
.await;
|
|
harness.advance_slot();
|
|
|
|
// Exit a validator.
|
|
let exited_validator = 0;
|
|
let exit =
|
|
harness.make_voluntary_exit(exited_validator, Epoch::new(spec.shard_committee_period));
|
|
let ObservationOutcome::New(verified_exit) = harness
|
|
.chain
|
|
.verify_voluntary_exit_for_gossip(exit.clone())
|
|
.unwrap()
|
|
else {
|
|
panic!("exit should verify");
|
|
};
|
|
harness.chain.import_voluntary_exit(verified_exit);
|
|
|
|
// Make a new block to include the exit.
|
|
harness
|
|
.extend_chain(
|
|
1,
|
|
BlockStrategy::OnCanonicalHead,
|
|
AttestationStrategy::AllValidators,
|
|
)
|
|
.await;
|
|
|
|
// Verify validator is actually exited.
|
|
assert_ne!(
|
|
harness
|
|
.get_current_state()
|
|
.validators()
|
|
.get(exited_validator as usize)
|
|
.unwrap()
|
|
.exit_epoch,
|
|
spec.far_future_epoch
|
|
);
|
|
|
|
// Clear the in-memory gossip cache & try to verify the same exit on gossip.
|
|
// It should still fail because gossip verification should check the validator's `exit_epoch`
|
|
// field in the head state.
|
|
harness
|
|
.chain
|
|
.observed_voluntary_exits
|
|
.lock()
|
|
.__reset_for_testing_only();
|
|
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_voluntary_exit_for_gossip(exit)
|
|
.unwrap_err(),
|
|
BeaconChainError::ExitValidationError(BlockOperationError::Invalid(
|
|
ExitInvalid::AlreadyExited(index)
|
|
)) if index == exited_validator
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn proposer_slashing() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
|
|
let validator_index1 = VALIDATOR_COUNT - 1;
|
|
let validator_index2 = VALIDATOR_COUNT - 2;
|
|
|
|
let slashing1 = harness.make_proposer_slashing(validator_index1 as u64);
|
|
|
|
// First slashing for this proposer should be allowed.
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing1.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
// Duplicate slashing should be detected.
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing1.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::AlreadyKnown
|
|
));
|
|
|
|
// Different slashing for the same index should be rejected
|
|
let slashing2 = ProposerSlashing {
|
|
signed_header_1: slashing1.signed_header_2,
|
|
signed_header_2: slashing1.signed_header_1,
|
|
};
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing2)
|
|
.unwrap(),
|
|
ObservationOutcome::AlreadyKnown
|
|
));
|
|
|
|
// Proposer slashing for a different index should be accepted
|
|
let slashing3 = harness.make_proposer_slashing(validator_index2 as u64);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing3)
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn proposer_slashing_duplicate_in_state() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
|
|
// Slash a validator.
|
|
let slashed_validator = 0;
|
|
let slashing = harness.make_proposer_slashing(slashed_validator);
|
|
let ObservationOutcome::New(verified_slashing) = harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing.clone())
|
|
.unwrap()
|
|
else {
|
|
panic!("slashing should verify");
|
|
};
|
|
harness.chain.import_proposer_slashing(verified_slashing);
|
|
|
|
// Make a new block to include the slashing.
|
|
harness
|
|
.extend_chain(
|
|
1,
|
|
BlockStrategy::OnCanonicalHead,
|
|
AttestationStrategy::AllValidators,
|
|
)
|
|
.await;
|
|
|
|
// Verify validator is actually slashed.
|
|
assert!(
|
|
harness
|
|
.get_current_state()
|
|
.validators()
|
|
.get(slashed_validator as usize)
|
|
.unwrap()
|
|
.slashed
|
|
);
|
|
|
|
// Clear the in-memory gossip cache & try to verify the same slashing on gossip.
|
|
// It should still fail because gossip verification should check the validator's `slashed` field
|
|
// in the head state.
|
|
harness
|
|
.chain
|
|
.observed_proposer_slashings
|
|
.lock()
|
|
.__reset_for_testing_only();
|
|
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_proposer_slashing_for_gossip(slashing)
|
|
.unwrap_err(),
|
|
BeaconChainError::ProposerSlashingValidationError(BlockOperationError::Invalid(
|
|
ProposerSlashingInvalid::ProposerNotSlashable(index)
|
|
)) if index == slashed_validator
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn attester_slashing() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
|
|
// First third of the validators
|
|
let first_third = (0..VALIDATOR_COUNT as u64 / 3).collect::<Vec<_>>();
|
|
// First half of the validators
|
|
let first_half = (0..VALIDATOR_COUNT as u64 / 2).collect::<Vec<_>>();
|
|
// Last third of the validators
|
|
let last_third = (2 * VALIDATOR_COUNT as u64 / 3..VALIDATOR_COUNT as u64).collect::<Vec<_>>();
|
|
// Last half of the validators
|
|
let second_half = (VALIDATOR_COUNT as u64 / 2..VALIDATOR_COUNT as u64).collect::<Vec<_>>();
|
|
|
|
// Slashing for first third of validators should be accepted.
|
|
let slashing1 = harness.make_attester_slashing(first_third);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing1.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
|
|
// Overlapping slashing for first half of validators should also be accepted.
|
|
let slashing2 = harness.make_attester_slashing(first_half);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing2.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
|
|
// Repeating slashing1 or slashing2 should be rejected
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing1.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::AlreadyKnown
|
|
));
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing2.clone())
|
|
.unwrap(),
|
|
ObservationOutcome::AlreadyKnown
|
|
));
|
|
|
|
// Slashing for last half of validators should be accepted (distinct from all existing)
|
|
let slashing3 = harness.make_attester_slashing(second_half);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing3)
|
|
.unwrap(),
|
|
ObservationOutcome::New(_)
|
|
));
|
|
// Slashing for last third (contained in last half) should be rejected.
|
|
let slashing4 = harness.make_attester_slashing(last_third);
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing4)
|
|
.unwrap(),
|
|
ObservationOutcome::AlreadyKnown
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn attester_slashing_duplicate_in_state() {
|
|
let db_path = tempdir().unwrap();
|
|
let store = get_store(&db_path);
|
|
let harness = get_harness(store.clone(), VALIDATOR_COUNT);
|
|
|
|
// Slash a validator.
|
|
let slashed_validator = 0;
|
|
let slashing = harness.make_attester_slashing(vec![slashed_validator]);
|
|
let ObservationOutcome::New(verified_slashing) = harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing.clone())
|
|
.unwrap()
|
|
else {
|
|
panic!("slashing should verify");
|
|
};
|
|
harness.chain.import_attester_slashing(verified_slashing);
|
|
|
|
// Make a new block to include the slashing.
|
|
harness
|
|
.extend_chain(
|
|
1,
|
|
BlockStrategy::OnCanonicalHead,
|
|
AttestationStrategy::AllValidators,
|
|
)
|
|
.await;
|
|
|
|
// Verify validator is actually slashed.
|
|
assert!(
|
|
harness
|
|
.get_current_state()
|
|
.validators()
|
|
.get(slashed_validator as usize)
|
|
.unwrap()
|
|
.slashed
|
|
);
|
|
|
|
// Clear the in-memory gossip cache & try to verify the same slashing on gossip.
|
|
// It should still fail because gossip verification should check the validator's `slashed` field
|
|
// in the head state.
|
|
harness
|
|
.chain
|
|
.observed_attester_slashings
|
|
.lock()
|
|
.__reset_for_testing_only();
|
|
|
|
assert!(matches!(
|
|
harness
|
|
.chain
|
|
.verify_attester_slashing_for_gossip(slashing)
|
|
.unwrap_err(),
|
|
BeaconChainError::AttesterSlashingValidationError(BlockOperationError::Invalid(
|
|
AttesterSlashingInvalid::NoSlashableIndices
|
|
))
|
|
));
|
|
}
|