testing around BeaconState and ChainSpec passing

beacon_chain/genesis/src/beacon_state.rs

@@ -1,6 +1,5 @@
 use spec::ChainSpec;
-use types::{BeaconState, CrosslinkRecord, ForkData, ValidatorStatus};
+use types::{BeaconState, CrosslinkRecord, ForkData};
-use validator_induction::ValidatorInductor;
 use validator_shuffling::{shard_and_committees_for_cycle, ValidatorAssignmentError};
 
 #[derive(Debug, PartialEq)]
@@ -11,26 +10,13 @@ pub enum Error {
 }
 
 pub fn genesis_beacon_state(spec: &ChainSpec) -> Result<BeaconState, Error> {
-    /*
-     * Parse the ValidatorRegistrations into ValidatorRecords and induct them.
-     *
-     * Ignore any records which fail proof-of-possession or are invalid.
-     */
-    let validators = {
-        let mut inductor = ValidatorInductor::new(0, spec.shard_count, vec![]);
-        for registration in &spec.initial_validators {
-            let _ = inductor.induct(&registration, ValidatorStatus::Active);
-        }
-        inductor.to_vec()
-    };
-
     /*
      * Assign the validators to shards, using all zeros as the seed.
      *
      * Crystallizedstate stores two cycles, so we simply repeat the same assignment twice.
      */
     let _shard_and_committee_for_slots = {
-        let mut a = shard_and_committees_for_cycle(&[0; 32], &validators, 0, &spec)?;
+        let mut a = shard_and_committees_for_cycle(&[0; 32], &spec.initial_validators, 0, &spec)?;
         let mut b = a.clone();
         a.append(&mut b);
         a
@@ -55,7 +41,8 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result<BeaconState, Error> {
         /*
          * Validator registry
          */
-        validator_registry: validators,
+        validator_registry: spec.initial_validators.clone(),
+        validator_balances: spec.initial_balances.clone(),
         validator_registry_latest_change_slot: spec.initial_slot_number,
         validator_registry_exit_count: 0,
         validator_registry_delta_chain_tip: spec.zero_hash,
@@ -118,6 +105,7 @@ mod tests {
         );
     }
 
+    /*
     #[test]
     fn test_genesis_bad_validator() {
         let mut spec = ChainSpec::foundation();
@@ -132,4 +120,5 @@ mod tests {
             spec.initial_validators.len() - 1
         );
     }
+    */
 }

beacon_chain/spec/src/foundation.rs

@@ -1,7 +1,7 @@
 use super::ChainSpec;
 use bls::{create_proof_of_possession, Keypair, PublicKey, SecretKey};
 
-use types::{Address, Hash256, ValidatorRegistration};
+use types::{Address, Hash256, ValidatorRecord};
 
 impl ChainSpec {
     /// Returns a `ChainSpec` compatible with the specification from Ethereum Foundation.
@@ -64,14 +64,15 @@ impl ChainSpec {
              * Intialization parameters
              */
             initial_validators: initial_validators_for_testing(),
+            initial_balances: vec![0,0,0,0],
             genesis_time: 1544672897,
             processed_pow_receipt_root: Hash256::from("pow_root".as_bytes()),
         }
     }
 }
 
-/// Generate a set of validator registrations to use with testing until the real chain starts.
+/// Generate a set of validator records to use with testing until the real chain starts.
-fn initial_validators_for_testing() -> Vec<ValidatorRegistration> {
+fn initial_validators_for_testing() -> Vec<ValidatorRecord> {
     // Some dummy private keys to start with.
     let key_strings = vec![
         "jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj",
@@ -94,14 +95,19 @@ fn initial_validators_for_testing() -> Vec<ValidatorRegistration> {
                 pk: public_key,
             }
         };
-        let validator_registration = ValidatorRegistration {
+        let validator_record = ValidatorRecord {
             pubkey: keypair.pk.clone(),    
-            withdrawal_shard: 0,
+            withdrawal_credentials: Hash256::zero(),
-            withdrawal_address: Address::random(),
+            randao_commitment: Hash256::zero(),
-            randao_commitment: Hash256::random(),
+            randao_layers: 0,
-            proof_of_possession: create_proof_of_possession(&keypair),
+            status: From::from(0),
+            latest_status_change_slot: 0,
+            exit_count: 0,
+            poc_commitment: Hash256::zero(),
+            last_poc_change_slot: 0,
+            second_last_poc_slot: 0
         };
-        initial_validators.push(validator_registration);
+        initial_validators.push(validator_record);
     }
 
     initial_validators

beacon_chain/spec/src/lib.rs

@@ -3,7 +3,7 @@ extern crate types;
 
 mod foundation;
 
-use types::{Address, Hash256, ValidatorRegistration};
+use types::{Address, Hash256, ValidatorRecord};
 
 #[derive(PartialEq, Debug)]
 pub struct ChainSpec {
@@ -60,7 +60,8 @@ pub struct ChainSpec {
     /*
      * Intialization parameters
      */
-    pub initial_validators: Vec<ValidatorRegistration>,
+    pub initial_validators: Vec<ValidatorRecord>,
+    pub initial_balances: Vec<u64>,
     pub genesis_time: u64,
     pub processed_pow_receipt_root: Hash256,
 }

beacon_chain/types/src/beacon_state.rs

@@ -7,7 +7,7 @@ use super::shard_reassignment_record::ShardReassignmentRecord;
 use super::validator_record::ValidatorRecord;
 use super::Hash256;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Default)]
 pub struct BeaconState {
     // Misc
     pub slot: u64,