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

.travis.yml

@@ -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

beacon_chain/attestation_validation/src/lib.rs

@@ -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;

beacon_chain/genesis/src/beacon_block.rs

@@ -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![],
         },

beacon_chain/genesis/src/beacon_state.rs

@@ -47,11 +47,16 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result<BeaconState, Error> {
         /*
          * Randomness and committees
          */
-        randao_mix: spec.zero_hash,
+        latest_randao_mixes: vec![spec.zero_hash; spec.latest_randao_mixes_length as usize],
-        next_seed: spec.zero_hash,
+        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
          */

beacon_chain/genesis/src/lib.rs

@@ -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};

beacon_chain/spec/src/foundation.rs

@@ -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
              */

beacon_chain/spec/src/lib.rs

@@ -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
      */

beacon_chain/types/src/beacon_block_body.rs

@@ -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),
         }

beacon_chain/types/src/beacon_state.rs

@@ -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 latest_randao_mixes: Vec<Hash256>,
-    pub next_seed: 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.latest_randao_mixes);
-        s.append(&self.next_seed);
+        s.append(&self.latest_vdf_outputs);
         s.append(&self.shard_committees_at_slots);
-        s.append(&self.persistent_committees);
+        s.append(&self.custody_challenges);
-        s.append(&self.persistent_committee_reassignments);
         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 (latest_randao_mixes, i) = <_>::ssz_decode(bytes, i)?;
-        let (next_seed, 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 (custody_challenges, i) = <_>::ssz_decode(bytes, i)?;
-        let (persistent_committee_reassignments, 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,
+                latest_randao_mixes,
-                next_seed,
+                latest_vdf_outputs,
                 shard_committees_at_slots,
-                persistent_committees,
+                custody_challenges,
-                persistent_committee_reassignments,
                 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),
+            latest_randao_mixes: <_>::random_for_test(rng),
-            next_seed: <_>::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),
+            custody_challenges: <_>::random_for_test(rng),
-            persistent_committee_reassignments: <_>::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),
         }

beacon_chain/types/src/test_utils/mod.rs

@@ -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![

beacon_chain/types/src/validator_record.rs

@@ -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,
         ))

beacon_chain/utils/bls/src/lib.rs

@@ -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

beacon_chain/validator_induction/src/inductor.rs

@@ -1,19 +1,19 @@
-use bls::{verify_proof_of_possession};
+use bls::verify_proof_of_possession;
-use types::{BeaconState, Deposit, ValidatorRecord, ValidatorStatus};
 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)
+    spec: &ChainSpec,
--> Result<usize, ValidatorInductionError> {
+) -> 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(
+fn min_empty_validator_index(state: &BeaconState, spec: &ChainSpec) -> Option<usize> {
-    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);
     }

beacon_chain/validator_induction/src/lib.rs

@@ -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};

lighthouse/beacon_chain/tests/chain_test.rs

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

lighthouse/db/src/disk_db.rs

@@ -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 }
     }

lighthouse/db/src/stores/beacon_state_store.rs

@@ -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);
 

lighthouse/main.rs

@@ -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();