cerc-io/lighthouse
16
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'update-block-and-state' into genesis_tests

Browse Source
This commit is contained in:
Kirk Baird 2019-01-15 11:09:26 +11:00
commit 3fd624923b
18 changed files with 137 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.travis.yml
View File

@ -1,5 +1,6 @@
language: rust
script:
- cargo fmt --all -- --check
- cargo build --verbose --all
- cargo test --verbose --all
rust:
@ -10,3 +11,5 @@ matrix:
allow_failures:
- rust: nightly
fast_finish: true
install:
- rustup component add rustfmt

6
beacon_chain/attestation_validation/src/lib.rs
View File

@ -14,9 +14,9 @@ mod justified_slot;
mod shard_block;
mod signature;
pub use crate::enums::{Invalid, Outcome, Error};
pub use crate::block_inclusion::validate_attestation_for_block;
pub use crate::justified_slot::validate_attestation_justified_slot;
pub use crate::enums::{Error, Invalid, Outcome};
pub use crate::justified_block::validate_attestation_justified_block_hash;
pub use crate::signature::validate_attestation_signature;
pub use crate::justified_slot::validate_attestation_justified_slot;
pub use crate::shard_block::validate_attestation_data_shard_block_hash;
pub use crate::signature::validate_attestation_signature;

3
beacon_chain/genesis/src/beacon_block.rs
View File

@ -16,6 +16,9 @@ pub fn genesis_beacon_block(state_root: Hash256, spec: &ChainSpec) -> BeaconBloc
proposer_slashings: vec![],
casper_slashings: vec![],
attestations: vec![],
custody_reseeds: vec![],
custody_challenges: vec![],
custody_responses: vec![],
deposits: vec![],
exits: vec![],
},

14
beacon_chain/genesis/src/beacon_state.rs
View File

@ -47,11 +47,16 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result<BeaconState, Error> {
/*
* Randomness and committees
*/
randao_mix: spec.zero_hash,
next_seed: spec.zero_hash,
latest_randao_mixes: vec![spec.zero_hash; spec.latest_randao_mixes_length as usize],
latest_vdf_outputs: vec![
spec.zero_hash;
(spec.latest_randao_mixes_length / spec.epoch_length) as usize
],
shard_committees_at_slots: vec![],
persistent_committees: vec![],
persistent_committee_reassignments: vec![],
/*
* Custody challenges
*/
custody_challenges: vec![],
/*
* Finality
*/
@ -66,6 +71,7 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result<BeaconState, Error> {
latest_block_roots: vec![spec.zero_hash; spec.epoch_length as usize],
latest_penalized_exit_balances: vec![],
latest_attestations: vec![],
batched_block_roots: vec![],
/*
* PoW receipt root
*/

2
beacon_chain/genesis/src/lib.rs
View File

@ -3,8 +3,8 @@ extern crate types;
extern crate validator_induction;
extern crate validator_shuffling;
mod beacon_state;
mod beacon_block;
mod beacon_state;
pub use crate::beacon_block::genesis_beacon_block;
pub use crate::beacon_state::{genesis_beacon_state, Error as GenesisError};

1
beacon_chain/spec/src/foundation.rs
View File

@ -24,6 +24,7 @@ impl ChainSpec {
beacon_chain_shard_number: u64::max_value(),
bls_withdrawal_prefix_byte: 0x00,
max_casper_votes: 1_024,
latest_randao_mixes_length: 8_192,
/*
* Deposit contract
*/

1
beacon_chain/spec/src/lib.rs
View File

@ -18,6 +18,7 @@ pub struct ChainSpec {
pub beacon_chain_shard_number: u64,
pub bls_withdrawal_prefix_byte: u8,
pub max_casper_votes: u64,
pub latest_randao_mixes_length: u64,
/*
* Deposit contract
*/

21
beacon_chain/types/src/beacon_block_body.rs
View File

@ -3,11 +3,20 @@ use super::{Attestation, CasperSlashing, Deposit, Exit, ProposerSlashing};
use crate::test_utils::TestRandom;
use rand::RngCore;
// The following types are just dummy classes as they will not be defined until
// Phase 1 (Sharding phase)
type CustodyReseed = usize;
type CustodyChallenge = usize;
type CustodyResponse = usize;
#[derive(Debug, PartialEq, Clone, Default)]
pub struct BeaconBlockBody {
pub proposer_slashings: Vec<ProposerSlashing>,
pub casper_slashings: Vec<CasperSlashing>,
pub attestations: Vec<Attestation>,
pub custody_reseeds: Vec<CustodyReseed>,
pub custody_challenges: Vec<CustodyChallenge>,
pub custody_responses: Vec<CustodyResponse>,
pub deposits: Vec<Deposit>,
pub exits: Vec<Exit>,
}
@ -17,6 +26,9 @@ impl Encodable for BeaconBlockBody {
s.append_vec(&self.proposer_slashings);
s.append_vec(&self.casper_slashings);
s.append_vec(&self.attestations);
s.append_vec(&self.custody_reseeds);
s.append_vec(&self.custody_challenges);
s.append_vec(&self.custody_responses);
s.append_vec(&self.deposits);
s.append_vec(&self.exits);
}
@ -27,6 +39,9 @@ impl Decodable for BeaconBlockBody {
let (proposer_slashings, i) = <_>::ssz_decode(bytes, i)?;
let (casper_slashings, i) = <_>::ssz_decode(bytes, i)?;
let (attestations, i) = <_>::ssz_decode(bytes, i)?;
let (custody_reseeds, i) = <_>::ssz_decode(bytes, i)?;
let (custody_challenges, i) = <_>::ssz_decode(bytes, i)?;
let (custody_responses, i) = <_>::ssz_decode(bytes, i)?;
let (deposits, i) = <_>::ssz_decode(bytes, i)?;
let (exits, i) = <_>::ssz_decode(bytes, i)?;
@ -35,6 +50,9 @@ impl Decodable for BeaconBlockBody {
proposer_slashings,
casper_slashings,
attestations,
custody_reseeds,
custody_challenges,
custody_responses,
deposits,
exits,
},
@ -49,6 +67,9 @@ impl<T: RngCore> TestRandom<T> for BeaconBlockBody {
proposer_slashings: <_>::random_for_test(rng),
casper_slashings: <_>::random_for_test(rng),
attestations: <_>::random_for_test(rng),
custody_reseeds: <_>::random_for_test(rng),
custody_challenges: <_>::random_for_test(rng),
custody_responses: <_>::random_for_test(rng),
deposits: <_>::random_for_test(rng),
exits: <_>::random_for_test(rng),
}

48
beacon_chain/types/src/beacon_state.rs
View File

@ -3,7 +3,6 @@ use super::crosslink_record::CrosslinkRecord;
use super::fork_data::ForkData;
use super::pending_attestation_record::PendingAttestationRecord;
use super::shard_committee::ShardCommittee;
use super::shard_reassignment_record::ShardReassignmentRecord;
use super::validator_record::ValidatorRecord;
use super::Hash256;
use crate::test_utils::TestRandom;
@ -11,6 +10,9 @@ use hashing::canonical_hash;
use rand::RngCore;
use ssz::{ssz_encode, Decodable, DecodeError, Encodable, SszStream};
// Custody will not be added to the specs until Phase 1 (Sharding Phase) so dummay class used.
type CustodyChallenge = usize;
#[derive(Debug, PartialEq, Clone, Default)]
pub struct BeaconState {
// Misc
@ -26,11 +28,12 @@ pub struct BeaconState {
pub validator_registry_delta_chain_tip: Hash256,
// Randomness and committees
pub randao_mix: Hash256,
pub next_seed: Hash256,
pub latest_randao_mixes: Vec<Hash256>,
pub latest_vdf_outputs: Vec<Hash256>,
pub shard_committees_at_slots: Vec<Vec<ShardCommittee>>,
pub persistent_committees: Vec<Vec<u32>>,
pub persistent_committee_reassignments: Vec<ShardReassignmentRecord>,
// Custody challenges
pub custody_challenges: Vec<CustodyChallenge>,
// Finality
pub previous_justified_slot: u64,
@ -43,8 +46,9 @@ pub struct BeaconState {
pub latest_block_roots: Vec<Hash256>,
pub latest_penalized_exit_balances: Vec<u64>,
pub latest_attestations: Vec<PendingAttestationRecord>,
pub batched_block_roots: Vec<Hash256>,
// PoW receipt root
// PoW receipt root (a.k.a. deposit root)
pub processed_pow_receipt_root: Hash256,
pub candidate_pow_receipt_roots: Vec<CandidatePoWReceiptRootRecord>,
}
@ -67,11 +71,10 @@ impl Encodable for BeaconState {
s.append(&self.validator_registry_latest_change_slot);
s.append(&self.validator_registry_exit_count);
s.append(&self.validator_registry_delta_chain_tip);
s.append(&self.randao_mix);
s.append(&self.next_seed);
s.append(&self.latest_randao_mixes);
s.append(&self.latest_vdf_outputs);
s.append(&self.shard_committees_at_slots);
s.append(&self.persistent_committees);
s.append(&self.persistent_committee_reassignments);
s.append(&self.custody_challenges);
s.append(&self.previous_justified_slot);
s.append(&self.justified_slot);
s.append(&self.justification_bitfield);
@ -80,6 +83,7 @@ impl Encodable for BeaconState {
s.append(&self.latest_block_roots);
s.append(&self.latest_penalized_exit_balances);
s.append(&self.latest_attestations);
s.append(&self.batched_block_roots);
s.append(&self.processed_pow_receipt_root);
s.append(&self.candidate_pow_receipt_roots);
}
@ -95,11 +99,10 @@ impl Decodable for BeaconState {
let (validator_registry_latest_change_slot, i) = <_>::ssz_decode(bytes, i)?;
let (validator_registry_exit_count, i) = <_>::ssz_decode(bytes, i)?;
let (validator_registry_delta_chain_tip, i) = <_>::ssz_decode(bytes, i)?;
let (randao_mix, i) = <_>::ssz_decode(bytes, i)?;
let (next_seed, i) = <_>::ssz_decode(bytes, i)?;
let (latest_randao_mixes, i) = <_>::ssz_decode(bytes, i)?;
let (latest_vdf_outputs, i) = <_>::ssz_decode(bytes, i)?;
let (shard_committees_at_slots, i) = <_>::ssz_decode(bytes, i)?;
let (persistent_committees, i) = <_>::ssz_decode(bytes, i)?;
let (persistent_committee_reassignments, i) = <_>::ssz_decode(bytes, i)?;
let (custody_challenges, i) = <_>::ssz_decode(bytes, i)?;
let (previous_justified_slot, i) = <_>::ssz_decode(bytes, i)?;
let (justified_slot, i) = <_>::ssz_decode(bytes, i)?;
let (justification_bitfield, i) = <_>::ssz_decode(bytes, i)?;
@ -108,6 +111,7 @@ impl Decodable for BeaconState {
let (latest_block_roots, i) = <_>::ssz_decode(bytes, i)?;
let (latest_penalized_exit_balances, i) = <_>::ssz_decode(bytes, i)?;
let (latest_attestations, i) = <_>::ssz_decode(bytes, i)?;
let (batched_block_roots, i) = <_>::ssz_decode(bytes, i)?;
let (processed_pow_receipt_root, i) = <_>::ssz_decode(bytes, i)?;
let (candidate_pow_receipt_roots, i) = <_>::ssz_decode(bytes, i)?;
@ -121,11 +125,10 @@ impl Decodable for BeaconState {
validator_registry_latest_change_slot,
validator_registry_exit_count,
validator_registry_delta_chain_tip,
randao_mix,
next_seed,
latest_randao_mixes,
latest_vdf_outputs,
shard_committees_at_slots,
persistent_committees,
persistent_committee_reassignments,
custody_challenges,
previous_justified_slot,
justified_slot,
justification_bitfield,
@ -134,6 +137,7 @@ impl Decodable for BeaconState {
latest_block_roots,
latest_penalized_exit_balances,
latest_attestations,
batched_block_roots,
processed_pow_receipt_root,
candidate_pow_receipt_roots,
},
@ -153,11 +157,10 @@ impl<T: RngCore> TestRandom<T> for BeaconState {
validator_registry_latest_change_slot: <_>::random_for_test(rng),
validator_registry_exit_count: <_>::random_for_test(rng),
validator_registry_delta_chain_tip: <_>::random_for_test(rng),
randao_mix: <_>::random_for_test(rng),
next_seed: <_>::random_for_test(rng),
latest_randao_mixes: <_>::random_for_test(rng),
latest_vdf_outputs: <_>::random_for_test(rng),
shard_committees_at_slots: <_>::random_for_test(rng),
persistent_committees: <_>::random_for_test(rng),
persistent_committee_reassignments: <_>::random_for_test(rng),
custody_challenges: <_>::random_for_test(rng),
previous_justified_slot: <_>::random_for_test(rng),
justified_slot: <_>::random_for_test(rng),
justification_bitfield: <_>::random_for_test(rng),
@ -166,6 +169,7 @@ impl<T: RngCore> TestRandom<T> for BeaconState {
latest_block_roots: <_>::random_for_test(rng),
latest_penalized_exit_balances: <_>::random_for_test(rng),
latest_attestations: <_>::random_for_test(rng),
batched_block_roots: <_>::random_for_test(rng),
processed_pow_receipt_root: <_>::random_for_test(rng),
candidate_pow_receipt_roots: <_>::random_for_test(rng),
}

10
beacon_chain/types/src/test_utils/mod.rs
View File

@ -6,12 +6,13 @@ pub mod address;
pub mod aggregate_signature;
pub mod bitfield;
pub mod hash256;
pub mod signature;
pub mod secret_key;
pub mod public_key;
pub mod secret_key;
pub mod signature;
pub trait TestRandom<T>
where T: RngCore
where
T: RngCore,
{
fn random_for_test(rng: &mut T) -> Self;
}
@ -35,7 +36,8 @@ impl<T: RngCore> TestRandom<T> for usize {
}
impl<T: RngCore, U> TestRandom<T> for Vec<U>
where U: TestRandom<T>
where
U: TestRandom<T>,
{
fn random_for_test(rng: &mut T) -> Self {
vec![

6
beacon_chain/types/src/validator_record.rs
View File

@ -1,5 +1,5 @@
use super::bls::PublicKey;
use super::{Hash256};
use super::Hash256;
use crate::test_utils::TestRandom;
use rand::RngCore;
use ssz::{Decodable, DecodeError, Encodable, SszStream};
@ -40,7 +40,7 @@ pub struct ValidatorRecord {
pub exit_count: u64,
pub custody_commitment: Hash256,
pub latest_custody_reseed_slot: u64,
pub penultimate_custody_reseed_slot: u64
pub penultimate_custody_reseed_slot: u64,
}
impl ValidatorRecord {
@ -132,7 +132,7 @@ impl Decodable for ValidatorRecord {
exit_count,
custody_commitment,
latest_custody_reseed_slot,
penultimate_custody_reseed_slot
penultimate_custody_reseed_slot,
},
i,
))

2
beacon_chain/utils/bls/src/lib.rs
View File

@ -19,8 +19,8 @@ pub use self::bls_aggregates::AggregatePublicKey;
pub const BLS_AGG_SIG_BYTE_SIZE: usize = 97;
use hashing::canonical_hash;
use std::default::Default;
use ssz::ssz_encode;
use std::default::Default;
fn extend_if_needed(hash: &mut Vec<u8>) {
// NOTE: bls_aggregates crate demands 48 bytes, this may be removed as we get closer to production

69
beacon_chain/validator_induction/src/inductor.rs
View File

@ -1,19 +1,19 @@
use bls::{verify_proof_of_possession};
use types::{BeaconState, Deposit, ValidatorRecord, ValidatorStatus};
use bls::verify_proof_of_possession;
use spec::ChainSpec;
use types::{BeaconState, Deposit, ValidatorRecord, ValidatorStatus};
#[derive(Debug, PartialEq, Clone)]
pub enum ValidatorInductionError {
InvalidShard,
InvaidProofOfPossession,
InvalidWithdrawalCredentials
InvalidWithdrawalCredentials,
}
pub fn process_deposit(
state: &mut BeaconState,
deposit: &Deposit,
spec: &ChainSpec)
-> Result<usize, ValidatorInductionError> {
spec: &ChainSpec,
) -> Result<usize, ValidatorInductionError> {
let deposit_input = &deposit.deposit_data.deposit_input;
let deposit_data = &deposit.deposit_data;
@ -22,18 +22,22 @@ pub fn process_deposit(
return Err(ValidatorInductionError::InvaidProofOfPossession);
}
let validator_index = state.validator_registry.iter()
let validator_index = state
.validator_registry
.iter()
.position(|validator| validator.pubkey == deposit_input.pubkey);
match validator_index {
Some(i) => {
if state.validator_registry[i].withdrawal_credentials == deposit_input.withdrawal_credentials {
if state.validator_registry[i].withdrawal_credentials
== deposit_input.withdrawal_credentials
{
state.validator_balances[i] += deposit_data.value;
return Ok(i);
}
Err(ValidatorInductionError::InvalidWithdrawalCredentials)
},
}
None => {
let validator = ValidatorRecord {
pubkey: deposit_input.pubkey.clone(),
@ -45,7 +49,7 @@ pub fn process_deposit(
exit_count: 0,
custody_commitment: deposit_input.custody_commitment,
latest_custody_reseed_slot: 0,
penultimate_custody_reseed_slot: 0
penultimate_custody_reseed_slot: 0,
};
match min_empty_validator_index(state, spec) {
@ -53,7 +57,7 @@ pub fn process_deposit(
state.validator_registry[i] = validator;
state.validator_balances[i] = deposit_data.value;
Ok(i)
},
}
None => {
state.validator_registry.push(validator);
state.validator_balances.push(deposit_data.value);
@ -64,14 +68,13 @@ pub fn process_deposit(
}
}
fn min_empty_validator_index(
state: &BeaconState,
spec: &ChainSpec
) -> Option<usize> {
fn min_empty_validator_index(state: &BeaconState, spec: &ChainSpec) -> Option<usize> {
for i in 0..state.validator_registry.len() {
if state.validator_balances[i] == 0
&& state.validator_registry[i].latest_status_change_slot
+ spec.zero_balance_validator_ttl <= state.slot {
+ spec.zero_balance_validator_ttl
<= state.slot
{
return Some(i);
}
}
@ -107,7 +110,10 @@ mod tests {
(dep.deposit_data.deposit_input.pubkey == val.pubkey)
& (dep.deposit_data.deposit_input.withdrawal_credentials == val.withdrawal_credentials)
& (dep.deposit_data.deposit_input.randao_commitment == val.randao_commitment)
& (verify_proof_of_possession(&dep.deposit_data.deposit_input.proof_of_possession, &val.pubkey))
& (verify_proof_of_possession(
&dep.deposit_data.deposit_input.proof_of_possession,
&val.pubkey,
))
}
#[test]
@ -120,7 +126,10 @@ mod tests {
let result = process_deposit(&mut state, &deposit, &spec);
assert_eq!(result.unwrap(), 0);
assert!(deposit_equals_record(&deposit, &state.validator_registry[0]));
assert!(deposit_equals_record(
&deposit,
&state.validator_registry[0]
));
assert_eq!(state.validator_registry.len(), 1);
assert_eq!(state.validator_balances.len(), 1);
}
@ -135,7 +144,10 @@ mod tests {
let result = process_deposit(&mut state, &deposit, &spec);
deposit.deposit_data.value = DEPOSIT_GWEI;
assert_eq!(result.unwrap(), i);
assert!(deposit_equals_record(&deposit, &state.validator_registry[i]));
assert!(deposit_equals_record(
&deposit,
&state.validator_registry[i]
));
assert_eq!(state.validator_registry.len(), i + 1);
assert_eq!(state.validator_balances.len(), i + 1);
}
@ -151,7 +163,8 @@ mod tests {
deposit.deposit_data.value = DEPOSIT_GWEI;
validator.pubkey = deposit.deposit_data.deposit_input.pubkey.clone();
validator.withdrawal_credentials = deposit.deposit_data.deposit_input.withdrawal_credentials;
validator.withdrawal_credentials =
deposit.deposit_data.deposit_input.withdrawal_credentials;
validator.randao_commitment = deposit.deposit_data.deposit_input.randao_commitment;
state.validator_registry.push(validator);
@ -160,7 +173,10 @@ mod tests {
let result = process_deposit(&mut state, &deposit, &spec);
assert_eq!(result.unwrap(), 0);
assert!(deposit_equals_record(&deposit, &state.validator_registry[0]));
assert!(deposit_equals_record(
&deposit,
&state.validator_registry[0]
));
assert_eq!(state.validator_balances[0], DEPOSIT_GWEI * 2);
assert_eq!(state.validator_registry.len(), 1);
assert_eq!(state.validator_balances.len(), 1);
@ -183,7 +199,10 @@ mod tests {
let result = process_deposit(&mut state, &deposit, &spec);
assert_eq!(result.unwrap(), 0);
assert!(deposit_equals_record(&deposit, &state.validator_registry[0]));
assert!(deposit_equals_record(
&deposit,
&state.validator_registry[0]
));
assert_eq!(state.validator_balances[0], DEPOSIT_GWEI);
assert_eq!(state.validator_registry.len(), 1);
assert_eq!(state.validator_balances.len(), 1);
@ -195,11 +214,15 @@ mod tests {
let mut deposit = get_deposit();
let spec = ChainSpec::foundation();
deposit.deposit_data.value = DEPOSIT_GWEI;
deposit.deposit_data.deposit_input.proof_of_possession = create_proof_of_possession(&Keypair::random());
deposit.deposit_data.deposit_input.proof_of_possession =
create_proof_of_possession(&Keypair::random());
let result = process_deposit(&mut state, &deposit, &spec);
assert_eq!(result, Err(ValidatorInductionError::InvaidProofOfPossession));
assert_eq!(
result,
Err(ValidatorInductionError::InvaidProofOfPossession)
);
assert_eq!(state.validator_registry.len(), 0);
assert_eq!(state.validator_balances.len(), 0);
}

4
beacon_chain/validator_induction/src/lib.rs
View File

@ -1,8 +1,8 @@
extern crate bls;
extern crate hashing;
extern crate types;
extern crate spec;
extern crate types;
mod inductor;
pub use crate::inductor::{ValidatorInductionError, process_deposit};
pub use crate::inductor::{process_deposit, ValidatorInductionError};

2
lighthouse/beacon_chain/tests/chain_test.rs
View File

@ -1,4 +1,4 @@
use chain::{BlockProcessingOutcome, BeaconChain};
use chain::{BeaconChain, BlockProcessingOutcome};
use db::{
stores::{BeaconBlockStore, BeaconStateStore},
MemoryDB,

3
lighthouse/db/src/disk_db.rs
View File

@ -44,7 +44,8 @@ impl DiskDB {
let db = match columns {
None => DB::open(&options, db_path),
Some(columns) => DB::open_cf(&options, db_path, columns),
}.expect("Unable to open local database");;
}
.expect("Unable to open local database");;
Self { db }
}

4
lighthouse/db/src/stores/beacon_state_store.rs
View File

@ -42,10 +42,10 @@ mod tests {
use super::super::super::MemoryDB;
use super::*;
use std::sync::Arc;
use ssz::ssz_encode;
use types::Hash256;
use std::sync::Arc;
use types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
use types::Hash256;
test_crud_for_store!(BeaconStateStore, DB_COLUMN);

8
lighthouse/main.rs
View File

@ -12,8 +12,8 @@ mod config;
use std::path::PathBuf;
use clap::{App, Arg};
use crate::config::LighthouseConfig;
use clap::{App, Arg};
use slog::Drain;
fn main() {
@ -32,13 +32,15 @@ fn main() {
.value_name("DIR")
.help("Data directory for keys and databases.")
.takes_value(true),
).arg(
)
.arg(
Arg::with_name("port")
.long("port")
.value_name("PORT")
.help("Network listen port for p2p connections.")
.takes_value(true),
).get_matches();
)
.get_matches();
let mut config = LighthouseConfig::default();