gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-05-07 08:52:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add untested minimum viable block processing

Browse Source
This commit is contained in:
Paul Hauner
2018-10-29 20:29:15 +01:00
parent e27c4106e9
commit 46da9b670f
21 changed files with 891 additions and 465 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
beacon_chain/validation/tests/block_validation/helpers.rs
View File

@@ -1,35 +1,14 @@
use std::sync::Arc;
use super::attestation_validation::helpers::{
generate_attestation,
insert_justified_block_hash,
};
use super::bls::{
Keypair,
};
use super::db::{
MemoryDB,
};
use super::db::stores::{
BeaconBlockStore,
PoWChainStore,
ValidatorStore,
};
use super::types::{
AttestationRecord,
AttesterMap,
BeaconBlock,
Hash256,
ProposerMap,
};
use super::attestation_validation::helpers::{generate_attestation, insert_justified_block_hash};
use super::bls::Keypair;
use super::db::stores::{BeaconBlockStore, PoWChainStore, ValidatorStore};
use super::db::MemoryDB;
use super::ssz::SszStream;
use super::ssz_helpers::ssz_beacon_block::SszBeaconBlock;
use super::types::{AttestationRecord, AttesterMap, BeaconBlock, Hash256, ProposerMap};
use super::validation::block_validation::{
BeaconBlockValidationContext,
SszBeaconBlockValidationError,
BeaconBlockStatus,
};
use super::ssz::{
SszStream,
BeaconBlockValidationContext, SszBeaconBlockValidationError,
};
#[derive(Debug)]
@@ -74,9 +53,15 @@ type ParentHashes = Vec<Hash256>;
/// Setup for a block validation function, without actually executing the
/// block validation function.
pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
-> (BeaconBlock, ParentHashes, AttesterMap, ProposerMap, TestStore)
{
pub fn setup_block_validation_scenario(
params: &BeaconBlockTestParams,
) -> (
BeaconBlock,
ParentHashes,
AttesterMap,
ProposerMap,
TestStore,
) {
let stores = TestStore::new();
let cycle_length = params.cycle_length;
@@ -100,7 +85,10 @@ pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
/*
* Store a valid PoW chain ref
*/
stores.pow_chain.put_block_hash(pow_chain_ref.as_ref()).unwrap();
stores
.pow_chain
.put_block_hash(pow_chain_ref.as_ref())
.unwrap();
/*
* Generate a minimum viable parent block and store it in the database.
@@ -110,7 +98,10 @@ pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
parent_block.slot = block_slot - 1;
parent_block.attestations.push(parent_attestation);
let parent_block_ssz = serialize_block(&parent_block);
stores.block.put_serialized_block(parent_hash.as_ref(), &parent_block_ssz).unwrap();
stores
.block
.put_serialized_block(parent_hash.as_ref(), &parent_block_ssz)
.unwrap();
let proposer_map = {
let mut proposer_map = ProposerMap::new();
@@ -132,24 +123,28 @@ pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
&mut parent_hashes,
&justified_block_hash,
block_slot,
attestation_slot);
attestation_slot,
);
/*
* For each shard in this slot, generate an attestation.
*/
for shard in 0..shards_per_slot {
let mut signing_keys = vec![];
let mut attesters = vec![];
/*
* Generate a random keypair for each validator and clone it into the
* list of keypairs. Store it in the database.
*/
let mut signing_keys = vec![];
let mut attesters = vec![];
/*
* Generate a random keypair for each validator and clone it into the
* list of keypairs. Store it in the database.
*/
for _ in 0..validators_per_shard {
let keypair = Keypair::random();
keypairs.push(keypair.clone());
stores.validator.put_public_key_by_index(i, &keypair.pk).unwrap();
signing_keys.push(Some(keypair.sk.clone()));
attesters.push(i);
i += 1;
let keypair = Keypair::random();
keypairs.push(keypair.clone());
stores
.validator
.put_public_key_by_index(i, &keypair.pk)
.unwrap();
signing_keys.push(Some(keypair.sk.clone()));
attesters.push(i);
i += 1;
}
attester_map.insert((attestation_slot, shard), attesters);
@@ -163,7 +158,8 @@ pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
cycle_length,
&parent_hashes,
&signing_keys[..],
&stores.block);
&stores.block,
);
attestations.push(attestation);
}
(attester_map, attestations, keypairs)
@@ -180,11 +176,7 @@ pub fn setup_block_validation_scenario(params: &BeaconBlockTestParams)
specials: vec![],
};
(block,
parent_hashes,
attester_map,
proposer_map,
stores)
(block, parent_hashes, attester_map, proposer_map, stores)
}
/// Helper function to take some BeaconBlock and SSZ serialize it.
@@ -199,25 +191,20 @@ pub fn serialize_block(b: &BeaconBlock) -> Vec<u8> {
/// Returns the Result returned from the block validation function.
pub fn run_block_validation_scenario<F>(
params: &BeaconBlockTestParams,
mutator_func: F)
-> Result<(BeaconBlockStatus, Option<BeaconBlock>), SszBeaconBlockValidationError>
where F: FnOnce(BeaconBlock, AttesterMap, ProposerMap, TestStore)
-> (BeaconBlock, AttesterMap, ProposerMap, TestStore)
mutator_func: F,
) -> Result<BeaconBlock, SszBeaconBlockValidationError>
where
F: FnOnce(BeaconBlock, AttesterMap, ProposerMap, TestStore)
-> (BeaconBlock, AttesterMap, ProposerMap, TestStore),
{
let (block,
parent_hashes,
attester_map,
proposer_map,
stores) = setup_block_validation_scenario(&params);
let (block, parent_hashes, attester_map, proposer_map, stores) =
setup_block_validation_scenario(&params);
let (block,
attester_map,
proposer_map,
stores) = mutator_func(block, attester_map, proposer_map, stores);
let (block, attester_map, proposer_map, stores) =
mutator_func(block, attester_map, proposer_map, stores);
let ssz_bytes = serialize_block(&block);
let ssz_block = SszBeaconBlock::from_slice(&ssz_bytes[..])
.unwrap();
let ssz_block = SszBeaconBlock::from_slice(&ssz_bytes[..]).unwrap();
let context = BeaconBlockValidationContext {
present_slot: params.validation_context_slot,
@@ -230,17 +217,17 @@ pub fn run_block_validation_scenario<F>(
attester_map: Arc::new(attester_map),
block_store: stores.block.clone(),
validator_store: stores.validator.clone(),
pow_store: stores.pow_chain.clone()
pow_store: stores.pow_chain.clone(),
};
let block_hash = Hash256::from(&ssz_block.block_hash()[..]);
let validation_status = context.validate_ssz_block(&block_hash, &ssz_block);
let validation_result = context.validate_ssz_block(&ssz_block);
/*
* If validation returned a block, make sure it's the same block we supplied to it.
*
* I.e., there were no errors during the serialization -> deserialization process.
*/
if let Ok((_, Some(returned_block))) = &validation_status {
if let Ok(returned_block) = &validation_result {
assert_eq!(*returned_block, block);
};
validation_status
validation_result
}

156
beacon_chain/validation/tests/block_validation/tests.rs
View File

@@ -1,26 +1,12 @@
use super::bls::{
AggregateSignature,
};
use super::bls::AggregateSignature;
use super::hashing::canonical_hash;
use super::helpers::{
BeaconBlockTestParams,
TestStore,
run_block_validation_scenario,
serialize_block,
};
use super::types::{
BeaconBlock,
Hash256,
ProposerMap,
run_block_validation_scenario, serialize_block, BeaconBlockTestParams, TestStore,
};
use super::ssz_helpers::ssz_beacon_block::SszBeaconBlock;
use super::validation::block_validation::{
SszBeaconBlockValidationError,
BeaconBlockStatus,
};
use super::validation::attestation_validation::{
AttestationValidationError,
};
use super::hashing::canonical_hash;
use super::types::{BeaconBlock, Hash256, ProposerMap};
use super::validation::attestation_validation::AttestationValidationError;
use super::validation::block_validation::SszBeaconBlockValidationError;
fn get_simple_params() -> BeaconBlockTestParams {
let validators_per_shard: usize = 5;
@@ -66,11 +52,9 @@ fn test_block_validation_valid() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status.unwrap().0, BeaconBlockStatus::NewBlock);
assert!(status.is_ok())
}
#[test]
@@ -83,15 +67,21 @@ fn test_block_validation_valid_known_block() {
*/
let block_ssz = serialize_block(&block);
let block_hash = canonical_hash(&block_ssz);
stores.block.put_serialized_block(&block_hash, &block_ssz).unwrap();
stores
.block
.put_serialized_block(&block_hash, &block_ssz)
.unwrap();
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status.unwrap(), (BeaconBlockStatus::KnownBlock, None));
/*
* This function does _not_ check if a block is already known.
*
* Known blocks will appear as valid blocks.
*/
assert!(status.is_ok())
}
#[test]
@@ -103,11 +93,12 @@ fn test_block_validation_parent_slot_too_high() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::ParentSlotHigherThanBlockSlot));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::ParentSlotHigherThanBlockSlot)
);
}
#[test]
@@ -119,9 +110,7 @@ fn test_block_validation_invalid_future_slot() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::FutureSlot));
}
@@ -131,8 +120,8 @@ fn test_block_validation_invalid_slot_already_finalized() {
let mut params = get_simple_params();
params.validation_context_finalized_slot = params.block_slot;
params.validation_context_justified_slot = params.validation_context_finalized_slot +
u64::from(params.cycle_length);
params.validation_context_justified_slot =
params.validation_context_finalized_slot + u64::from(params.cycle_length);
let mutator = |block, attester_map, proposer_map, stores| {
/*
@@ -141,11 +130,12 @@ fn test_block_validation_invalid_slot_already_finalized() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::SlotAlreadyFinalized));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::SlotAlreadyFinalized)
);
}
#[test]
@@ -157,11 +147,12 @@ fn test_block_validation_invalid_unknown_pow_hash() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::UnknownPoWChainRef));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::UnknownPoWChainRef)
);
}
#[test]
@@ -173,11 +164,12 @@ fn test_block_validation_invalid_unknown_parent_hash() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::UnknownParentHash));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::UnknownParentHash)
);
}
#[test]
@@ -192,36 +184,44 @@ fn test_block_validation_invalid_1st_attestation_signature() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::AttestationValidationError(
AttestationValidationError::BadAggregateSignature)));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::AttestationValidationError(
AttestationValidationError::BadAggregateSignature
))
);
}
#[test]
fn test_block_validation_invalid_no_parent_proposer_signature() {
let params = get_simple_params();
let mutator = |block: BeaconBlock, attester_map, mut proposer_map: ProposerMap, stores: TestStore| {
/*
* Set the proposer for this slot to be a validator that does not exist.
*/
let ssz = {
let parent_hash = block.parent_hash().unwrap().as_ref();
stores.block.get_serialized_block(parent_hash).unwrap().unwrap()
let mutator =
|block: BeaconBlock, attester_map, mut proposer_map: ProposerMap, stores: TestStore| {
/*
* Set the proposer for this slot to be a validator that does not exist.
*/
let ssz = {
let parent_hash = block.parent_hash().unwrap().as_ref();
stores
.block
.get_serialized_block(parent_hash)
.unwrap()
.unwrap()
};
let parent_block_slot = SszBeaconBlock::from_slice(&ssz[..]).unwrap().slot();
proposer_map.insert(parent_block_slot, params.total_validators + 1);
(block, attester_map, proposer_map, stores)
};
let parent_block_slot = SszBeaconBlock::from_slice(&ssz[..]).unwrap().slot();
proposer_map.insert(parent_block_slot, params.total_validators + 1);
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::NoProposerSignature));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::NoProposerSignature)
);
}
#[test]
@@ -236,9 +236,7 @@ fn test_block_validation_invalid_bad_proposer_map() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::BadProposerMap));
}
@@ -255,10 +253,12 @@ fn test_block_validation_invalid_2nd_attestation_signature() {
(block, attester_map, proposer_map, stores)
};
let status = run_block_validation_scenario(
&params,
mutator);
let status = run_block_validation_scenario(&params, mutator);
assert_eq!(status, Err(SszBeaconBlockValidationError::AttestationValidationError(
AttestationValidationError::BadAggregateSignature)));
assert_eq!(
status,
Err(SszBeaconBlockValidationError::AttestationValidationError(
AttestationValidationError::BadAggregateSignature
))
);
}