gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-09 19:51:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

BlockProcessing testing (#559)

Browse Source 
* Add valid_deposit test and build_with_deposit method

* Insert_deposit takes a num_deposit param

* Deposit with spec.max_effective_balance

* Copy int_to_bytes32 implem from beacon_chain_builder

* Add debug information to insert_deposit

* Remove length-proof assertion

* Insert_deposit displays error

* Batch deposits now pass tests

* Optimize insert_deposit

* Rename insert_deposits and set num_deposits to 2 in valid_deposit test

* update test_utils to pass tests

* fix typo in test_utils

* update cast in test_utils

* Add DepositCountInvalid tests

* Add tests for bad deposit signature

* Add tests and test utils in test_builder

* Return error instead of ok on bad signature

* Update DepositTestTask enum

* Add comment about manually setting deposit_count and deposit_index

* add badblsbytes test

* add bad_index var for clarity ; remove underflow test

* cargo fmt

* Add insert 3 exits tests

* Add validator_unknwon test

* Add far_future_epoch test and already exited

* Add MaxVoluntaryExits + 1 test

* Add exit_already_initiated test

* Add exit_not_active test

* Add too_young_to_leave test

* Cargo fmt

* Confirm already_anitiated test

* Fix typo in enum variant

* Adjust some tests to return ok(()) and revert changes for early return in per_block_processing.rs

* cargo fmt

* Adjust AlreadyIniated test to expect Ok(()) and revert changes in per_block_processing.rs

* Remove extraneous newline

* Add insert_valid_attester_slashing

* Initial cargo fmt

* Add NotSlashable test

* Cargo fmt

* Remove AttestationDataIdentical

* Make test_task pass through reference ; fix max_attester_slashing_plus_one test

* Initial cargo fmt

* Add InvalidIndexedAttestation1 and 2

* Add comments

* Add ProposalsIdenticalTest

* Add ProposalsIdentical test

* Cargo fmt

* Add ProposerUnknown test

* Add ProposalEpochMismatch test

* Add BadProposal1Signature and Badproposal2Signature tests

* Add ProposerNotSlashable test

* Derive PartialEq and use if instead of match

* Merge attestation tests

* Remove useless AlreadyInitiated variant in beacon_state

* Remove MaxOperations plus one tests for each operation

* Clean comments

* add IncludedTooLate and BadTargetEpoch tests

* Update AttestationDataBuilder call in operation_pool testing

* Cargo fmt

* Remove BadIndex enum variant, unused in the code

* Cargo fmt

* Cargo fmt updated

* simply increment deposit_count instead of hardsetting deposit_index in insert_deposits

* Fix bad_merkle_proof when calling insert_deposits
This commit is contained in:
pscott
2019-11-12 06:09:33 +01:00
committed by Paul Hauner
parent 613fdbeda6
commit c7b3a7abd8
16 changed files with 1936 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
eth2/state_processing/src/common/get_indexed_attestation.rs
View File

@@ -98,11 +98,31 @@ mod test {
.map(|validator_index| &keypairs[*validator_index].sk)
.collect::<Vec<_>>();
let mut attestation_builder =
TestingAttestationBuilder::new(&state, &cc.committee, cc.slot, shard, &spec);
let mut attestation_builder = TestingAttestationBuilder::new(
&AttestationTestTask::Valid,
&state,
&cc.committee,
cc.slot,
shard,
&spec,
);
attestation_builder
.sign(&bit_0_indices, &bit_0_keys, &state.fork, &spec, false)
.sign(&bit_1_indices, &bit_1_keys, &state.fork, &spec, true);
.sign(
&AttestationTestTask::Valid,
&bit_0_indices,
&bit_0_keys,
&state.fork,
&spec,
false,
)
.sign(
&AttestationTestTask::Valid,
&bit_1_indices,
&bit_1_keys,
&state.fork,
&spec,
true,
);
let attestation = attestation_builder.build();
let indexed_attestation = get_indexed_attestation(&state, &attestation).unwrap();

252
eth2/state_processing/src/per_block_processing/block_processing_builder.rs
View File

@@ -1,5 +1,9 @@
use std::convert::TryInto;
use tree_hash::SignedRoot;
use types::test_utils::{TestingBeaconBlockBuilder, TestingBeaconStateBuilder};
use types::test_utils::{
AttestationTestTask, AttesterSlashingTestTask, DepositTestTask, ExitTestTask,
ProposerSlashingTestTask, TestingBeaconBlockBuilder, TestingBeaconStateBuilder,
};
use types::*;
pub struct BlockProcessingBuilder<T: EthSpec> {
@@ -30,6 +34,252 @@ impl<T: EthSpec> BlockProcessingBuilder<T> {
self.state_builder.build_caches(&spec).unwrap();
}
pub fn build_with_n_deposits(
mut self,
num_deposits: u64,
test_task: DepositTestTask,
randao_sk: Option<SecretKey>,
previous_block_root: Option<Hash256>,
spec: &ChainSpec,
) -> (BeaconBlock<T>, BeaconState<T>) {
let (mut state, keypairs) = self.state_builder.build();
let builder = &mut self.block_builder;
builder.set_slot(state.slot);
match previous_block_root {
Some(root) => builder.set_parent_root(root),
None => builder.set_parent_root(Hash256::from_slice(
&state.latest_block_header.signed_root(),
)),
}
let proposer_index = state
.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)
.unwrap();
let keypair = &keypairs[proposer_index];
match randao_sk {
Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
}
self.block_builder.insert_deposits(
spec.max_effective_balance,
test_task,
1,
num_deposits,
&mut state,
spec,
);
let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
(block, state)
}
pub fn build_with_n_exits(
mut self,
num_exits: usize,
test_task: ExitTestTask,
randao_sk: Option<SecretKey>,
previous_block_root: Option<Hash256>,
spec: &ChainSpec,
) -> (BeaconBlock<T>, BeaconState<T>) {
let (mut state, keypairs) = self.state_builder.build();
let builder = &mut self.block_builder;
builder.set_slot(state.slot);
match previous_block_root {
Some(root) => builder.set_parent_root(root),
None => builder.set_parent_root(Hash256::from_slice(
&state.latest_block_header.signed_root(),
)),
}
let proposer_index = state
.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)
.unwrap();
let keypair = &keypairs[proposer_index];
match randao_sk {
Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
}
match test_task {
ExitTestTask::AlreadyInitiated => {
for _ in 0..2 {
self.block_builder.insert_exit(
&test_task,
&mut state,
(0 as usize).try_into().unwrap(),
&keypairs[0].sk,
spec,
)
}
}
_ => {
for (i, keypair) in keypairs.iter().take(num_exits).enumerate() {
self.block_builder.insert_exit(
&test_task,
&mut state,
(i as usize).try_into().unwrap(),
&keypair.sk,
spec,
);
}
}
}
let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
(block, state)
}
pub fn build_with_n_attestations(
mut self,
test_task: &AttestationTestTask,
num_attestations: u64,
randao_sk: Option<SecretKey>,
previous_block_root: Option<Hash256>,
spec: &ChainSpec,
) -> (BeaconBlock<T>, BeaconState<T>) {
let (state, keypairs) = self.state_builder.build();
let builder = &mut self.block_builder;
builder.set_slot(state.slot);
match previous_block_root {
Some(root) => builder.set_parent_root(root),
None => builder.set_parent_root(Hash256::from_slice(
&state.latest_block_header.signed_root(),
)),
}
let proposer_index = state
.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)
.unwrap();
let keypair = &keypairs[proposer_index];
match randao_sk {
Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
}
let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
self.block_builder
.insert_attestations(
test_task,
&state,
&all_secret_keys,
num_attestations as usize,
spec,
)
.unwrap();
let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
(block, state)
}
pub fn build_with_attester_slashing(
mut self,
test_task: &AttesterSlashingTestTask,
num_attester_slashings: u64,
randao_sk: Option<SecretKey>,
previous_block_root: Option<Hash256>,
spec: &ChainSpec,
) -> (BeaconBlock<T>, BeaconState<T>) {
let (state, keypairs) = self.state_builder.build();
let builder = &mut self.block_builder;
builder.set_slot(state.slot);
match previous_block_root {
Some(root) => builder.set_parent_root(root),
None => builder.set_parent_root(Hash256::from_slice(
&state.latest_block_header.signed_root(),
)),
}
let proposer_index = state
.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)
.unwrap();
let keypair = &keypairs[proposer_index];
match randao_sk {
Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
}
let mut validator_indices = vec![];
let mut secret_keys = vec![];
for i in 0..num_attester_slashings {
validator_indices.push(i);
secret_keys.push(&keypairs[i as usize].sk);
}
for _ in 0..num_attester_slashings {
self.block_builder.insert_attester_slashing(
test_task,
&validator_indices,
&secret_keys,
&state.fork,
spec,
);
}
let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
(block, state)
}
pub fn build_with_proposer_slashing(
mut self,
test_task: &ProposerSlashingTestTask,
num_proposer_slashings: u64,
randao_sk: Option<SecretKey>,
previous_block_root: Option<Hash256>,
spec: &ChainSpec,
) -> (BeaconBlock<T>, BeaconState<T>) {
let (state, keypairs) = self.state_builder.build();
let builder = &mut self.block_builder;
builder.set_slot(state.slot);
match previous_block_root {
Some(root) => builder.set_parent_root(root),
None => builder.set_parent_root(Hash256::from_slice(
&state.latest_block_header.signed_root(),
)),
}
let proposer_index = state
.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)
.unwrap();
let keypair = &keypairs[proposer_index];
match randao_sk {
Some(sk) => builder.set_randao_reveal(&sk, &state.fork, spec),
None => builder.set_randao_reveal(&keypair.sk, &state.fork, spec),
}
for i in 0..num_proposer_slashings {
let validator_indices = i;
let secret_keys = &keypairs[i as usize].sk;
self.block_builder.insert_proposer_slashing(
test_task,
validator_indices,
&secret_keys,
&state.fork,
spec,
);
}
let block = self.block_builder.build(&keypair.sk, &state.fork, spec);
(block, state)
}
pub fn build(
mut self,
randao_sk: Option<SecretKey>,

8
eth2/state_processing/src/per_block_processing/errors.rs
View File

@@ -190,8 +190,6 @@ pub enum ProposerSlashingInvalid {
#[derive(Debug, PartialEq)]
pub enum AttesterSlashingInvalid {
/// The attestation data is identical, an attestation cannot conflict with itself.
AttestationDataIdentical,
/// The attestations were not in conflict.
NotSlashable,
/// The first `IndexedAttestation` was invalid.
@@ -257,8 +255,6 @@ pub enum AttestationInvalid {
CustodyBitfieldNotSubset,
/// There was no known committee in this `epoch` for the given shard and slot.
NoCommitteeForShard { shard: u64, slot: Slot },
/// The validator index was unknown.
UnknownValidator(u64),
/// The attestation signature verification failed.
BadSignature,
/// The shard block root was not set to zero. This is a phase 0 requirement.
@@ -311,8 +307,6 @@ pub enum IndexedAttestationInvalid {
#[derive(Debug, PartialEq)]
pub enum DepositInvalid {
/// The deposit index does not match the state index.
BadIndex { state: u64, deposit: u64 },
/// The signature (proof-of-possession) does not match the given pubkey.
BadSignature,
/// The signature or pubkey does not represent a valid BLS point.
@@ -331,7 +325,7 @@ pub enum ExitInvalid {
/// The specified validator has a non-maximum exit epoch.
AlreadyExited(u64),
/// The specified validator has already initiated exit.
AlreadyInitiatedExited(u64),
AlreadyInitiatedExit(u64),
/// The exit is for a future epoch.
FutureEpoch { state: Epoch, exit: Epoch },
/// The validator has not been active for long enough.

1253
eth2/state_processing/src/per_block_processing/tests.rs
View File

File diff suppressed because it is too large Load Diff

1
eth2/state_processing/src/per_block_processing/verify_attestation.rs
View File

@@ -61,6 +61,7 @@ pub fn verify_attestation_for_state<T: EthSpec>(
spec: &ChainSpec,
) -> Result<()> {
let data = &attestation.data;
verify!(
data.crosslink.shard < T::ShardCount::to_u64(),
Invalid::BadShard

35
eth2/state_processing/src/test_utils.rs
View File

@@ -1,5 +1,8 @@
use log::info;
use types::test_utils::{TestingBeaconBlockBuilder, TestingBeaconStateBuilder};
use types::test_utils::{
AttestationTestTask, AttesterSlashingTestTask, DepositTestTask, ExitTestTask,
ProposerSlashingTestTask, TestingBeaconBlockBuilder, TestingBeaconStateBuilder,
};
use types::{EthSpec, *};
pub struct BlockBuilder<T: EthSpec> {
@@ -77,6 +80,7 @@ impl<T: EthSpec> BlockBuilder<T> {
let validator_index = validators_iter.next().expect("Insufficient validators.");
builder.insert_proposer_slashing(
&ProposerSlashingTestTask::Valid,
validator_index,
&keypairs[validator_index as usize].sk,
&state.fork,
@@ -102,7 +106,13 @@ impl<T: EthSpec> BlockBuilder<T> {
secret_keys.push(&keypairs[validator_index as usize].sk);
}
builder.insert_attester_slashing(&attesters, &secret_keys, &state.fork, spec);
builder.insert_attester_slashing(
&AttesterSlashingTestTask::Valid,
&attesters,
&secret_keys,
&state.fork,
spec,
);
}
info!(
"Inserted {} attester slashings.",
@@ -113,6 +123,7 @@ impl<T: EthSpec> BlockBuilder<T> {
let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
builder
.insert_attestations(
&AttestationTestTask::Valid,
&state,
&all_secret_keys,
self.num_attestations as usize,
@@ -125,15 +136,14 @@ impl<T: EthSpec> BlockBuilder<T> {
);
// Insert `Deposit` objects.
for i in 0..self.num_deposits {
builder.insert_deposit(
32_000_000_000,
state.eth1_data.deposit_count + (i as u64),
&state,
spec,
);
}
state.eth1_data.deposit_count += self.num_deposits as u64;
builder.insert_deposits(
32_000_000_000,
DepositTestTask::NoReset,
state.eth1_data.deposit_count,
self.num_deposits as u64,
&mut state,
spec,
);
info!("Inserted {} deposits.", builder.block.body.deposits.len());
// Insert the maximum possible number of `Exit` objects.
@@ -141,7 +151,8 @@ impl<T: EthSpec> BlockBuilder<T> {
let validator_index = validators_iter.next().expect("Insufficient validators.");
builder.insert_exit(
&state,
&ExitTestTask::Valid,
&mut state,
validator_index,
&keypairs[validator_index as usize].sk,
spec,