Revert "Merge pull request #200 from sigp/new-structure"

This reverts commit d7a3545be1, reversing
changes made to 1da06c156c.

eth2/types/src/attestation.rs

@@ -0,0 +1,112 @@
+use super::{AggregatePublicKey, AggregateSignature, AttestationData, Bitfield, Hash256};
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct Attestation {
+    pub aggregation_bitfield: Bitfield,
+    pub data: AttestationData,
+    pub custody_bitfield: Bitfield,
+    pub aggregate_signature: AggregateSignature,
+}
+
+impl Attestation {
+    pub fn canonical_root(&self) -> Hash256 {
+        Hash256::from(&self.hash_tree_root()[..])
+    }
+
+    pub fn signable_message(&self, custody_bit: bool) -> Vec<u8> {
+        self.data.signable_message(custody_bit)
+    }
+
+    pub fn verify_signature(
+        &self,
+        group_public_key: &AggregatePublicKey,
+        custody_bit: bool,
+        // TODO: use domain.
+        _domain: u64,
+    ) -> bool {
+        self.aggregate_signature
+            .verify(&self.signable_message(custody_bit), group_public_key)
+    }
+}
+
+impl Encodable for Attestation {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.aggregation_bitfield);
+        s.append(&self.data);
+        s.append(&self.custody_bitfield);
+        s.append(&self.aggregate_signature);
+    }
+}
+
+impl Decodable for Attestation {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (aggregation_bitfield, i) = Bitfield::ssz_decode(bytes, i)?;
+        let (data, i) = AttestationData::ssz_decode(bytes, i)?;
+        let (custody_bitfield, i) = Bitfield::ssz_decode(bytes, i)?;
+        let (aggregate_signature, i) = AggregateSignature::ssz_decode(bytes, i)?;
+
+        let attestation_record = Self {
+            aggregation_bitfield,
+            data,
+            custody_bitfield,
+            aggregate_signature,
+        };
+        Ok((attestation_record, i))
+    }
+}
+
+impl TreeHash for Attestation {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.aggregation_bitfield.hash_tree_root());
+        result.append(&mut self.data.hash_tree_root());
+        result.append(&mut self.custody_bitfield.hash_tree_root());
+        result.append(&mut self.aggregate_signature.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Attestation {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            data: <_>::random_for_test(rng),
+            aggregation_bitfield: <_>::random_for_test(rng),
+            custody_bitfield: <_>::random_for_test(rng),
+            aggregate_signature: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Attestation::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Attestation::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/attestation_data.rs

@@ -0,0 +1,142 @@
+use crate::test_utils::TestRandom;
+use crate::{AttestationDataAndCustodyBit, Crosslink, Epoch, Hash256, Slot};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+pub const SSZ_ATTESTION_DATA_LENGTH: usize = {
+    8 +             // slot
+    8 +             // shard
+    32 +            // beacon_block_hash
+    32 +            // epoch_boundary_root
+    32 +            // shard_block_hash
+    32 +            // latest_crosslink_hash
+    8 +             // justified_epoch
+    32 // justified_block_root
+};
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash)]
+pub struct AttestationData {
+    pub slot: Slot,
+    pub shard: u64,
+    pub beacon_block_root: Hash256,
+    pub epoch_boundary_root: Hash256,
+    pub shard_block_root: Hash256,
+    pub latest_crosslink: Crosslink,
+    pub justified_epoch: Epoch,
+    pub justified_block_root: Hash256,
+}
+
+impl Eq for AttestationData {}
+
+impl AttestationData {
+    pub fn canonical_root(&self) -> Hash256 {
+        Hash256::from(&self.hash_tree_root()[..])
+    }
+
+    pub fn signable_message(&self, custody_bit: bool) -> Vec<u8> {
+        let attestation_data_and_custody_bit = AttestationDataAndCustodyBit {
+            data: self.clone(),
+            custody_bit,
+        };
+        attestation_data_and_custody_bit.hash_tree_root()
+    }
+}
+
+impl Encodable for AttestationData {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.slot);
+        s.append(&self.shard);
+        s.append(&self.beacon_block_root);
+        s.append(&self.epoch_boundary_root);
+        s.append(&self.shard_block_root);
+        s.append(&self.latest_crosslink);
+        s.append(&self.justified_epoch);
+        s.append(&self.justified_block_root);
+    }
+}
+
+impl Decodable for AttestationData {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (slot, i) = <_>::ssz_decode(bytes, i)?;
+        let (shard, i) = <_>::ssz_decode(bytes, i)?;
+        let (beacon_block_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (epoch_boundary_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (shard_block_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (latest_crosslink, i) = <_>::ssz_decode(bytes, i)?;
+        let (justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (justified_block_root, i) = <_>::ssz_decode(bytes, i)?;
+
+        let attestation_data = AttestationData {
+            slot,
+            shard,
+            beacon_block_root,
+            epoch_boundary_root,
+            shard_block_root,
+            latest_crosslink,
+            justified_epoch,
+            justified_block_root,
+        };
+        Ok((attestation_data, i))
+    }
+}
+
+impl TreeHash for AttestationData {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.slot.hash_tree_root());
+        result.append(&mut self.shard.hash_tree_root());
+        result.append(&mut self.beacon_block_root.hash_tree_root());
+        result.append(&mut self.epoch_boundary_root.hash_tree_root());
+        result.append(&mut self.shard_block_root.hash_tree_root());
+        result.append(&mut self.latest_crosslink.hash_tree_root());
+        result.append(&mut self.justified_epoch.hash_tree_root());
+        result.append(&mut self.justified_block_root.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for AttestationData {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            slot: <_>::random_for_test(rng),
+            shard: <_>::random_for_test(rng),
+            beacon_block_root: <_>::random_for_test(rng),
+            epoch_boundary_root: <_>::random_for_test(rng),
+            shard_block_root: <_>::random_for_test(rng),
+            latest_crosslink: <_>::random_for_test(rng),
+            justified_epoch: <_>::random_for_test(rng),
+            justified_block_root: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = AttestationData::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = AttestationData::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -0,0 +1,81 @@
+use super::AttestationData;
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize)]
+pub struct AttestationDataAndCustodyBit {
+    pub data: AttestationData,
+    pub custody_bit: bool,
+}
+
+impl Encodable for AttestationDataAndCustodyBit {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.data);
+        // TODO: deal with bools
+    }
+}
+
+impl Decodable for AttestationDataAndCustodyBit {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (data, i) = <_>::ssz_decode(bytes, i)?;
+        let custody_bit = false;
+
+        let attestation_data_and_custody_bit = AttestationDataAndCustodyBit { data, custody_bit };
+
+        Ok((attestation_data_and_custody_bit, i))
+    }
+}
+
+impl TreeHash for AttestationDataAndCustodyBit {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.data.hash_tree_root());
+        // TODO: add bool ssz
+        // result.append(custody_bit.hash_tree_root());
+        ssz::hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for AttestationDataAndCustodyBit {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            data: <_>::random_for_test(rng),
+            // TODO: deal with bools
+            custody_bit: false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+
+        let original = AttestationDataAndCustodyBit::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = AttestationDataAndCustodyBit::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/attester_slashing.rs

@@ -0,0 +1,80 @@
+use crate::{test_utils::TestRandom, SlashableAttestation};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct AttesterSlashing {
+    pub slashable_attestation_1: SlashableAttestation,
+    pub slashable_attestation_2: SlashableAttestation,
+}
+
+impl Encodable for AttesterSlashing {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.slashable_attestation_1);
+        s.append(&self.slashable_attestation_2);
+    }
+}
+
+impl Decodable for AttesterSlashing {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (slashable_attestation_1, i) = <_>::ssz_decode(bytes, i)?;
+        let (slashable_attestation_2, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            AttesterSlashing {
+                slashable_attestation_1,
+                slashable_attestation_2,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for AttesterSlashing {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.slashable_attestation_1.hash_tree_root());
+        result.append(&mut self.slashable_attestation_2.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for AttesterSlashing {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            slashable_attestation_1: <_>::random_for_test(rng),
+            slashable_attestation_2: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = AttesterSlashing::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = AttesterSlashing::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/beacon_block.rs

@@ -0,0 +1,155 @@
+use crate::test_utils::TestRandom;
+use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, ProposalSignedData, Slot};
+use bls::Signature;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct BeaconBlock {
+    pub slot: Slot,
+    pub parent_root: Hash256,
+    pub state_root: Hash256,
+    pub randao_reveal: Signature,
+    pub eth1_data: Eth1Data,
+    pub signature: Signature,
+    pub body: BeaconBlockBody,
+}
+
+impl BeaconBlock {
+    /// Produce the first block of the Beacon Chain.
+    pub fn genesis(state_root: Hash256, spec: &ChainSpec) -> BeaconBlock {
+        BeaconBlock {
+            slot: spec.genesis_slot,
+            parent_root: spec.zero_hash,
+            state_root,
+            randao_reveal: spec.empty_signature.clone(),
+            eth1_data: Eth1Data {
+                deposit_root: spec.zero_hash,
+                block_hash: spec.zero_hash,
+            },
+            signature: spec.empty_signature.clone(),
+            body: BeaconBlockBody {
+                proposer_slashings: vec![],
+                attester_slashings: vec![],
+                attestations: vec![],
+                deposits: vec![],
+                exits: vec![],
+            },
+        }
+    }
+
+    pub fn canonical_root(&self) -> Hash256 {
+        Hash256::from(&self.hash_tree_root()[..])
+    }
+
+    pub fn proposal_root(&self, spec: &ChainSpec) -> Hash256 {
+        let block_without_signature_root = {
+            let mut block_without_signature = self.clone();
+            block_without_signature.signature = spec.empty_signature.clone();
+            block_without_signature.canonical_root()
+        };
+
+        let proposal = ProposalSignedData {
+            slot: self.slot,
+            shard: spec.beacon_chain_shard_number,
+            block_root: block_without_signature_root,
+        };
+        Hash256::from(&proposal.hash_tree_root()[..])
+    }
+}
+
+impl Encodable for BeaconBlock {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.slot);
+        s.append(&self.parent_root);
+        s.append(&self.state_root);
+        s.append(&self.randao_reveal);
+        s.append(&self.eth1_data);
+        s.append(&self.signature);
+        s.append(&self.body);
+    }
+}
+
+impl Decodable for BeaconBlock {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (slot, i) = <_>::ssz_decode(bytes, i)?;
+        let (parent_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (state_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (randao_reveal, i) = <_>::ssz_decode(bytes, i)?;
+        let (eth1_data, i) = <_>::ssz_decode(bytes, i)?;
+        let (signature, i) = <_>::ssz_decode(bytes, i)?;
+        let (body, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                slot,
+                parent_root,
+                state_root,
+                randao_reveal,
+                eth1_data,
+                signature,
+                body,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for BeaconBlock {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.slot.hash_tree_root());
+        result.append(&mut self.parent_root.hash_tree_root());
+        result.append(&mut self.state_root.hash_tree_root());
+        result.append(&mut self.randao_reveal.hash_tree_root());
+        result.append(&mut self.eth1_data.hash_tree_root());
+        result.append(&mut self.signature.hash_tree_root());
+        result.append(&mut self.body.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for BeaconBlock {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            slot: <_>::random_for_test(rng),
+            parent_root: <_>::random_for_test(rng),
+            state_root: <_>::random_for_test(rng),
+            randao_reveal: <_>::random_for_test(rng),
+            eth1_data: <_>::random_for_test(rng),
+            signature: <_>::random_for_test(rng),
+            body: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = BeaconBlock::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = BeaconBlock::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/beacon_block_body.rs

@@ -0,0 +1,99 @@
+use super::{Attestation, AttesterSlashing, Deposit, Exit, ProposerSlashing};
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+pub struct BeaconBlockBody {
+    pub proposer_slashings: Vec<ProposerSlashing>,
+    pub attester_slashings: Vec<AttesterSlashing>,
+    pub attestations: Vec<Attestation>,
+    pub deposits: Vec<Deposit>,
+    pub exits: Vec<Exit>,
+}
+
+impl Encodable for BeaconBlockBody {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_vec(&self.proposer_slashings);
+        s.append_vec(&self.attester_slashings);
+        s.append_vec(&self.attestations);
+        s.append_vec(&self.deposits);
+        s.append_vec(&self.exits);
+    }
+}
+
+impl Decodable for BeaconBlockBody {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (proposer_slashings, i) = <_>::ssz_decode(bytes, i)?;
+        let (attester_slashings, i) = <_>::ssz_decode(bytes, i)?;
+        let (attestations, i) = <_>::ssz_decode(bytes, i)?;
+        let (deposits, i) = <_>::ssz_decode(bytes, i)?;
+        let (exits, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                proposer_slashings,
+                attester_slashings,
+                attestations,
+                deposits,
+                exits,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for BeaconBlockBody {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.proposer_slashings.hash_tree_root());
+        result.append(&mut self.attester_slashings.hash_tree_root());
+        result.append(&mut self.attestations.hash_tree_root());
+        result.append(&mut self.deposits.hash_tree_root());
+        result.append(&mut self.exits.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for BeaconBlockBody {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            proposer_slashings: <_>::random_for_test(rng),
+            attester_slashings: <_>::random_for_test(rng),
+            attestations: <_>::random_for_test(rng),
+            deposits: <_>::random_for_test(rng),
+            exits: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = BeaconBlockBody::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = BeaconBlockBody::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/casper_slashing.rs

@@ -0,0 +1,81 @@
+use super::SlashableVoteData;
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct CasperSlashing {
+    pub slashable_vote_data_1: SlashableVoteData,
+    pub slashable_vote_data_2: SlashableVoteData,
+}
+
+impl Encodable for CasperSlashing {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.slashable_vote_data_1);
+        s.append(&self.slashable_vote_data_2);
+    }
+}
+
+impl Decodable for CasperSlashing {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (slashable_vote_data_1, i) = <_>::ssz_decode(bytes, i)?;
+        let (slashable_vote_data_2, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            CasperSlashing {
+                slashable_vote_data_1,
+                slashable_vote_data_2,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for CasperSlashing {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.slashable_vote_data_1.hash_tree_root());
+        result.append(&mut self.slashable_vote_data_2.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for CasperSlashing {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            slashable_vote_data_1: <_>::random_for_test(rng),
+            slashable_vote_data_2: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = CasperSlashing::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = CasperSlashing::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/crosslink.rs

@@ -0,0 +1,91 @@
+use crate::test_utils::TestRandom;
+use crate::{Epoch, Hash256};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash)]
+pub struct Crosslink {
+    pub epoch: Epoch,
+    pub shard_block_root: Hash256,
+}
+
+impl Crosslink {
+    /// Generates a new instance where `dynasty` and `hash` are both zero.
+    pub fn zero() -> Self {
+        Self {
+            epoch: Epoch::new(0),
+            shard_block_root: Hash256::zero(),
+        }
+    }
+}
+
+impl Encodable for Crosslink {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.epoch);
+        s.append(&self.shard_block_root);
+    }
+}
+
+impl Decodable for Crosslink {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (shard_block_root, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                epoch,
+                shard_block_root,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Crosslink {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.epoch.hash_tree_root());
+        result.append(&mut self.shard_block_root.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Crosslink {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            epoch: <_>::random_for_test(rng),
+            shard_block_root: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Crosslink::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Crosslink::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/deposit.rs

@@ -0,0 +1,87 @@
+use super::{DepositData, Hash256};
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct Deposit {
+    pub branch: Vec<Hash256>,
+    pub index: u64,
+    pub deposit_data: DepositData,
+}
+
+impl Encodable for Deposit {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_vec(&self.branch);
+        s.append(&self.index);
+        s.append(&self.deposit_data);
+    }
+}
+
+impl Decodable for Deposit {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (branch, i) = <_>::ssz_decode(bytes, i)?;
+        let (index, i) = <_>::ssz_decode(bytes, i)?;
+        let (deposit_data, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                branch,
+                index,
+                deposit_data,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Deposit {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.branch.hash_tree_root());
+        result.append(&mut self.index.hash_tree_root());
+        result.append(&mut self.deposit_data.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Deposit {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            branch: <_>::random_for_test(rng),
+            index: <_>::random_for_test(rng),
+            deposit_data: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Deposit::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Deposit::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/deposit_data.rs

@@ -0,0 +1,87 @@
+use super::DepositInput;
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct DepositData {
+    pub amount: u64,
+    pub timestamp: u64,
+    pub deposit_input: DepositInput,
+}
+
+impl Encodable for DepositData {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.amount);
+        s.append(&self.timestamp);
+        s.append(&self.deposit_input);
+    }
+}
+
+impl Decodable for DepositData {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (amount, i) = <_>::ssz_decode(bytes, i)?;
+        let (timestamp, i) = <_>::ssz_decode(bytes, i)?;
+        let (deposit_input, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                amount,
+                timestamp,
+                deposit_input,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for DepositData {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.amount.hash_tree_root());
+        result.append(&mut self.timestamp.hash_tree_root());
+        result.append(&mut self.deposit_input.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for DepositData {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            amount: <_>::random_for_test(rng),
+            timestamp: <_>::random_for_test(rng),
+            deposit_input: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = DepositData::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = DepositData::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/deposit_input.rs

@@ -0,0 +1,88 @@
+use super::Hash256;
+use crate::test_utils::TestRandom;
+use bls::{PublicKey, Signature};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct DepositInput {
+    pub pubkey: PublicKey,
+    pub withdrawal_credentials: Hash256,
+    pub proof_of_possession: Signature,
+}
+
+impl Encodable for DepositInput {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.pubkey);
+        s.append(&self.withdrawal_credentials);
+        s.append(&self.proof_of_possession);
+    }
+}
+
+impl Decodable for DepositInput {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (pubkey, i) = <_>::ssz_decode(bytes, i)?;
+        let (withdrawal_credentials, i) = <_>::ssz_decode(bytes, i)?;
+        let (proof_of_possession, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                pubkey,
+                withdrawal_credentials,
+                proof_of_possession,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for DepositInput {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.pubkey.hash_tree_root());
+        result.append(&mut self.withdrawal_credentials.hash_tree_root());
+        result.append(&mut self.proof_of_possession.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for DepositInput {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            pubkey: <_>::random_for_test(rng),
+            withdrawal_credentials: <_>::random_for_test(rng),
+            proof_of_possession: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = DepositInput::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = DepositInput::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/eth1_data.rs

@@ -0,0 +1,82 @@
+use super::Hash256;
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+// Note: this is refer to as DepositRootVote in specs
+#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+pub struct Eth1Data {
+    pub deposit_root: Hash256,
+    pub block_hash: Hash256,
+}
+
+impl Encodable for Eth1Data {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.deposit_root);
+        s.append(&self.block_hash);
+    }
+}
+
+impl Decodable for Eth1Data {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (deposit_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (block_hash, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                deposit_root,
+                block_hash,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Eth1Data {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.deposit_root.hash_tree_root());
+        result.append(&mut self.block_hash.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Eth1Data {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            deposit_root: <_>::random_for_test(rng),
+            block_hash: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Eth1Data::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Eth1Data::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/eth1_data_vote.rs

@@ -0,0 +1,82 @@
+use super::Eth1Data;
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+// Note: this is refer to as DepositRootVote in specs
+#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+pub struct Eth1DataVote {
+    pub eth1_data: Eth1Data,
+    pub vote_count: u64,
+}
+
+impl Encodable for Eth1DataVote {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.eth1_data);
+        s.append(&self.vote_count);
+    }
+}
+
+impl Decodable for Eth1DataVote {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (eth1_data, i) = <_>::ssz_decode(bytes, i)?;
+        let (vote_count, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                eth1_data,
+                vote_count,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Eth1DataVote {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.eth1_data.hash_tree_root());
+        result.append(&mut self.vote_count.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Eth1DataVote {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            eth1_data: <_>::random_for_test(rng),
+            vote_count: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Eth1DataVote::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Eth1DataVote::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/exit.rs

@@ -0,0 +1,87 @@
+use crate::{test_utils::TestRandom, Epoch};
+use bls::Signature;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct Exit {
+    pub epoch: Epoch,
+    pub validator_index: u64,
+    pub signature: Signature,
+}
+
+impl Encodable for Exit {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.epoch);
+        s.append(&self.validator_index);
+        s.append(&self.signature);
+    }
+}
+
+impl Decodable for Exit {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
+        let (signature, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                epoch,
+                validator_index,
+                signature,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Exit {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.epoch.hash_tree_root());
+        result.append(&mut self.validator_index.hash_tree_root());
+        result.append(&mut self.signature.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Exit {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            epoch: <_>::random_for_test(rng),
+            validator_index: <_>::random_for_test(rng),
+            signature: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Exit::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Exit::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/fork.rs

@@ -0,0 +1,86 @@
+use crate::{test_utils::TestRandom, Epoch};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize)]
+pub struct Fork {
+    pub previous_version: u64,
+    pub current_version: u64,
+    pub epoch: Epoch,
+}
+
+impl Encodable for Fork {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.previous_version);
+        s.append(&self.current_version);
+        s.append(&self.epoch);
+    }
+}
+
+impl Decodable for Fork {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (previous_version, i) = <_>::ssz_decode(bytes, i)?;
+        let (current_version, i) = <_>::ssz_decode(bytes, i)?;
+        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                previous_version,
+                current_version,
+                epoch,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Fork {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.previous_version.hash_tree_root());
+        result.append(&mut self.current_version.hash_tree_root());
+        result.append(&mut self.epoch.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Fork {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            previous_version: <_>::random_for_test(rng),
+            current_version: <_>::random_for_test(rng),
+            epoch: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Fork::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Fork::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/free_attestation.rs

@@ -0,0 +1,12 @@
+/// Note: this object does not actually exist in the spec.
+///
+/// We use it for managing attestations that have not been aggregated.
+use super::{AttestationData, Signature};
+use serde_derive::Serialize;
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct FreeAttestation {
+    pub data: AttestationData,
+    pub signature: Signature,
+    pub validator_index: u64,
+}

eth2/types/src/lib.rs

@@ -0,0 +1,75 @@
+pub mod test_utils;
+
+pub mod attestation;
+pub mod attestation_data;
+pub mod attestation_data_and_custody_bit;
+pub mod attester_slashing;
+pub mod beacon_block;
+pub mod beacon_block_body;
+pub mod beacon_state;
+pub mod casper_slashing;
+pub mod crosslink;
+pub mod deposit;
+pub mod deposit_data;
+pub mod deposit_input;
+pub mod eth1_data;
+pub mod eth1_data_vote;
+pub mod exit;
+pub mod fork;
+pub mod free_attestation;
+pub mod pending_attestation;
+pub mod proposal_signed_data;
+pub mod proposer_slashing;
+pub mod readers;
+pub mod shard_reassignment_record;
+pub mod slashable_attestation;
+pub mod slashable_vote_data;
+pub mod slot_epoch_height;
+pub mod spec;
+pub mod validator;
+pub mod validator_registry;
+pub mod validator_registry_delta_block;
+
+use ethereum_types::{H160, H256, U256};
+use std::collections::HashMap;
+
+pub use crate::attestation::Attestation;
+pub use crate::attestation_data::AttestationData;
+pub use crate::attestation_data_and_custody_bit::AttestationDataAndCustodyBit;
+pub use crate::attester_slashing::AttesterSlashing;
+pub use crate::beacon_block::BeaconBlock;
+pub use crate::beacon_block_body::BeaconBlockBody;
+pub use crate::beacon_state::BeaconState;
+pub use crate::casper_slashing::CasperSlashing;
+pub use crate::crosslink::Crosslink;
+pub use crate::deposit::Deposit;
+pub use crate::deposit_data::DepositData;
+pub use crate::deposit_input::DepositInput;
+pub use crate::eth1_data::Eth1Data;
+pub use crate::eth1_data_vote::Eth1DataVote;
+pub use crate::exit::Exit;
+pub use crate::fork::Fork;
+pub use crate::free_attestation::FreeAttestation;
+pub use crate::pending_attestation::PendingAttestation;
+pub use crate::proposal_signed_data::ProposalSignedData;
+pub use crate::proposer_slashing::ProposerSlashing;
+pub use crate::slashable_attestation::SlashableAttestation;
+pub use crate::slashable_vote_data::SlashableVoteData;
+pub use crate::slot_epoch_height::{Epoch, Slot};
+pub use crate::spec::ChainSpec;
+pub use crate::validator::{StatusFlags as ValidatorStatusFlags, Validator};
+pub use crate::validator_registry_delta_block::ValidatorRegistryDeltaBlock;
+
+pub type Hash256 = H256;
+pub type Address = H160;
+pub type EthBalance = U256;
+pub type Bitfield = boolean_bitfield::BooleanBitfield;
+pub type BitfieldError = boolean_bitfield::Error;
+
+/// Maps a (slot, shard_id) to attestation_indices.
+pub type AttesterMap = HashMap<(u64, u64), Vec<usize>>;
+
+/// Maps a slot to a block proposer.
+pub type ProposerMap = HashMap<u64, usize>;
+
+pub use bls::{AggregatePublicKey, AggregateSignature, Keypair, PublicKey, Signature};

eth2/types/src/pending_attestation.rs

@@ -0,0 +1,93 @@
+use crate::test_utils::TestRandom;
+use crate::{AttestationData, Bitfield, Slot};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct PendingAttestation {
+    pub aggregation_bitfield: Bitfield,
+    pub data: AttestationData,
+    pub custody_bitfield: Bitfield,
+    pub inclusion_slot: Slot,
+}
+
+impl Encodable for PendingAttestation {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.aggregation_bitfield);
+        s.append(&self.data);
+        s.append(&self.custody_bitfield);
+        s.append(&self.inclusion_slot);
+    }
+}
+
+impl Decodable for PendingAttestation {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (aggregation_bitfield, i) = <_>::ssz_decode(bytes, i)?;
+        let (data, i) = <_>::ssz_decode(bytes, i)?;
+        let (custody_bitfield, i) = <_>::ssz_decode(bytes, i)?;
+        let (inclusion_slot, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                data,
+                aggregation_bitfield,
+                custody_bitfield,
+                inclusion_slot,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for PendingAttestation {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.aggregation_bitfield.hash_tree_root());
+        result.append(&mut self.data.hash_tree_root());
+        result.append(&mut self.custody_bitfield.hash_tree_root());
+        result.append(&mut self.inclusion_slot.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for PendingAttestation {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            data: <_>::random_for_test(rng),
+            aggregation_bitfield: <_>::random_for_test(rng),
+            custody_bitfield: <_>::random_for_test(rng),
+            inclusion_slot: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = PendingAttestation::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = PendingAttestation::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/proposal_signed_data.rs

@@ -0,0 +1,87 @@
+use crate::test_utils::TestRandom;
+use crate::{Hash256, Slot};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+pub struct ProposalSignedData {
+    pub slot: Slot,
+    pub shard: u64,
+    pub block_root: Hash256,
+}
+
+impl Encodable for ProposalSignedData {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.slot);
+        s.append(&self.shard);
+        s.append(&self.block_root);
+    }
+}
+
+impl Decodable for ProposalSignedData {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (slot, i) = <_>::ssz_decode(bytes, i)?;
+        let (shard, i) = <_>::ssz_decode(bytes, i)?;
+        let (block_root, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            ProposalSignedData {
+                slot,
+                shard,
+                block_root,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for ProposalSignedData {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.slot.hash_tree_root());
+        result.append(&mut self.shard.hash_tree_root());
+        result.append(&mut self.block_root.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for ProposalSignedData {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            slot: <_>::random_for_test(rng),
+            shard: <_>::random_for_test(rng),
+            block_root: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ProposalSignedData::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ProposalSignedData::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/proposer_slashing.rs

@@ -0,0 +1,100 @@
+use super::ProposalSignedData;
+use crate::test_utils::TestRandom;
+use bls::Signature;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct ProposerSlashing {
+    pub proposer_index: u64,
+    pub proposal_data_1: ProposalSignedData,
+    pub proposal_signature_1: Signature,
+    pub proposal_data_2: ProposalSignedData,
+    pub proposal_signature_2: Signature,
+}
+
+impl Encodable for ProposerSlashing {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.proposer_index);
+        s.append(&self.proposal_data_1);
+        s.append(&self.proposal_signature_1);
+        s.append(&self.proposal_data_2);
+        s.append(&self.proposal_signature_2);
+    }
+}
+
+impl Decodable for ProposerSlashing {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (proposer_index, i) = <_>::ssz_decode(bytes, i)?;
+        let (proposal_data_1, i) = <_>::ssz_decode(bytes, i)?;
+        let (proposal_signature_1, i) = <_>::ssz_decode(bytes, i)?;
+        let (proposal_data_2, i) = <_>::ssz_decode(bytes, i)?;
+        let (proposal_signature_2, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            ProposerSlashing {
+                proposer_index,
+                proposal_data_1,
+                proposal_signature_1,
+                proposal_data_2,
+                proposal_signature_2,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for ProposerSlashing {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.proposer_index.hash_tree_root());
+        result.append(&mut self.proposal_data_1.hash_tree_root());
+        result.append(&mut self.proposal_signature_1.hash_tree_root());
+        result.append(&mut self.proposal_data_2.hash_tree_root());
+        result.append(&mut self.proposal_signature_2.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for ProposerSlashing {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            proposer_index: <_>::random_for_test(rng),
+            proposal_data_1: <_>::random_for_test(rng),
+            proposal_signature_1: <_>::random_for_test(rng),
+            proposal_data_2: <_>::random_for_test(rng),
+            proposal_signature_2: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ProposerSlashing::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ProposerSlashing::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/readers/block_reader.rs

@@ -0,0 +1,40 @@
+use crate::{BeaconBlock, Hash256, Slot};
+use std::fmt::Debug;
+
+/// The `BeaconBlockReader` provides interfaces for reading a subset of fields of a `BeaconBlock`.
+///
+/// The purpose of this trait is to allow reading from either;
+///  - a standard `BeaconBlock` struct, or
+///  - a SSZ serialized byte array.
+///
+/// Note: presently, direct SSZ reading has not been implemented so this trait is being used for
+/// "future proofing".
+pub trait BeaconBlockReader: Debug + PartialEq {
+    fn slot(&self) -> Slot;
+    fn parent_root(&self) -> Hash256;
+    fn state_root(&self) -> Hash256;
+    fn canonical_root(&self) -> Hash256;
+    fn into_beacon_block(self) -> Option<BeaconBlock>;
+}
+
+impl BeaconBlockReader for BeaconBlock {
+    fn slot(&self) -> Slot {
+        self.slot
+    }
+
+    fn parent_root(&self) -> Hash256 {
+        self.parent_root
+    }
+
+    fn state_root(&self) -> Hash256 {
+        self.state_root
+    }
+
+    fn canonical_root(&self) -> Hash256 {
+        self.canonical_root()
+    }
+
+    fn into_beacon_block(self) -> Option<BeaconBlock> {
+        Some(self)
+    }
+}

eth2/types/src/readers/mod.rs

@@ -0,0 +1,5 @@
+mod block_reader;
+mod state_reader;
+
+pub use self::block_reader::BeaconBlockReader;
+pub use self::state_reader::BeaconStateReader;

eth2/types/src/readers/state_reader.rs

@@ -0,0 +1,30 @@
+use crate::{BeaconState, Hash256, Slot};
+use std::fmt::Debug;
+
+/// The `BeaconStateReader` provides interfaces for reading a subset of fields of a `BeaconState`.
+///
+/// The purpose of this trait is to allow reading from either;
+///  - a standard `BeaconState` struct, or
+///  - a SSZ serialized byte array.
+///
+/// Note: presently, direct SSZ reading has not been implemented so this trait is being used for
+/// "future proofing".
+pub trait BeaconStateReader: Debug + PartialEq {
+    fn slot(&self) -> Slot;
+    fn canonical_root(&self) -> Hash256;
+    fn into_beacon_state(self) -> Option<BeaconState>;
+}
+
+impl BeaconStateReader for BeaconState {
+    fn slot(&self) -> Slot {
+        self.slot
+    }
+
+    fn canonical_root(&self) -> Hash256 {
+        self.canonical_root()
+    }
+
+    fn into_beacon_state(self) -> Option<BeaconState> {
+        Some(self)
+    }
+}

eth2/types/src/shard_reassignment_record.rs

@@ -0,0 +1,86 @@
+use crate::{test_utils::TestRandom, Slot};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct ShardReassignmentRecord {
+    pub validator_index: u64,
+    pub shard: u64,
+    pub slot: Slot,
+}
+
+impl Encodable for ShardReassignmentRecord {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.validator_index);
+        s.append(&self.shard);
+        s.append(&self.slot);
+    }
+}
+
+impl Decodable for ShardReassignmentRecord {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
+        let (shard, i) = <_>::ssz_decode(bytes, i)?;
+        let (slot, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                validator_index,
+                shard,
+                slot,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for ShardReassignmentRecord {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.validator_index.hash_tree_root());
+        result.append(&mut self.shard.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for ShardReassignmentRecord {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            validator_index: <_>::random_for_test(rng),
+            shard: <_>::random_for_test(rng),
+            slot: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ShardReassignmentRecord::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ShardReassignmentRecord::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/slashable_attestation.rs

@@ -0,0 +1,92 @@
+use crate::{test_utils::TestRandom, AggregateSignature, AttestationData, Bitfield};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct SlashableAttestation {
+    pub validator_indices: Vec<u64>,
+    pub data: AttestationData,
+    pub custody_bitfield: Bitfield,
+    pub aggregate_signature: AggregateSignature,
+}
+
+impl Encodable for SlashableAttestation {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_vec(&self.validator_indices);
+        s.append(&self.data);
+        s.append(&self.custody_bitfield);
+        s.append(&self.aggregate_signature);
+    }
+}
+
+impl Decodable for SlashableAttestation {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (validator_indices, i) = <_>::ssz_decode(bytes, i)?;
+        let (data, i) = <_>::ssz_decode(bytes, i)?;
+        let (custody_bitfield, i) = <_>::ssz_decode(bytes, i)?;
+        let (aggregate_signature, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            SlashableAttestation {
+                validator_indices,
+                data,
+                custody_bitfield,
+                aggregate_signature,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for SlashableAttestation {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.validator_indices.hash_tree_root());
+        result.append(&mut self.data.hash_tree_root());
+        result.append(&mut self.custody_bitfield.hash_tree_root());
+        result.append(&mut self.aggregate_signature.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for SlashableAttestation {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            validator_indices: <_>::random_for_test(rng),
+            data: <_>::random_for_test(rng),
+            custody_bitfield: <_>::random_for_test(rng),
+            aggregate_signature: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = SlashableAttestation::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = SlashableAttestation::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/slashable_vote_data.rs

@@ -0,0 +1,94 @@
+use super::AttestationData;
+use crate::test_utils::TestRandom;
+use bls::AggregateSignature;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct SlashableVoteData {
+    pub custody_bit_0_indices: Vec<u32>,
+    pub custody_bit_1_indices: Vec<u32>,
+    pub data: AttestationData,
+    pub aggregate_signature: AggregateSignature,
+}
+
+impl Encodable for SlashableVoteData {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_vec(&self.custody_bit_0_indices);
+        s.append_vec(&self.custody_bit_1_indices);
+        s.append(&self.data);
+        s.append(&self.aggregate_signature);
+    }
+}
+
+impl Decodable for SlashableVoteData {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (custody_bit_0_indices, i) = <_>::ssz_decode(bytes, i)?;
+        let (custody_bit_1_indices, i) = <_>::ssz_decode(bytes, i)?;
+        let (data, i) = <_>::ssz_decode(bytes, i)?;
+        let (aggregate_signature, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            SlashableVoteData {
+                custody_bit_0_indices,
+                custody_bit_1_indices,
+                data,
+                aggregate_signature,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for SlashableVoteData {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.custody_bit_0_indices.hash_tree_root());
+        result.append(&mut self.custody_bit_1_indices.hash_tree_root());
+        result.append(&mut self.data.hash_tree_root());
+        result.append(&mut self.aggregate_signature.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for SlashableVoteData {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            custody_bit_0_indices: <_>::random_for_test(rng),
+            custody_bit_1_indices: <_>::random_for_test(rng),
+            data: <_>::random_for_test(rng),
+            aggregate_signature: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = SlashableVoteData::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = SlashableVoteData::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/slot_epoch_height.rs

@@ -0,0 +1,763 @@
+/// The `Slot` `Epoch`, `Height` types are defined as newtypes over u64 to enforce type-safety between
+/// the three types.
+///
+/// `Slot`, `Epoch` and `Height` have implementations which permit conversion, comparison and math operations
+/// between each and `u64`, however specifically not between each other.
+///
+/// All math operations on `Slot` and `Epoch` are saturating, they never wrap.
+///
+/// It would be easy to define `PartialOrd` and other traits generically across all types which
+/// implement `Into<u64>`, however this would allow operations between `Slots`, `Epochs` and
+/// `Heights` which may lead to programming errors which are not detected by the compiler.
+use crate::test_utils::TestRandom;
+use rand::RngCore;
+use serde_derive::Serialize;
+use slog;
+use ssz::{hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use std::cmp::{Ord, Ordering};
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::iter::Iterator;
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, Sub, SubAssign};
+
+macro_rules! impl_from_into_u64 {
+    ($main: ident) => {
+        impl From<u64> for $main {
+            fn from(n: u64) -> $main {
+                $main(n)
+            }
+        }
+
+        impl Into<u64> for $main {
+            fn into(self) -> u64 {
+                self.0
+            }
+        }
+
+        impl $main {
+            pub fn as_u64(&self) -> u64 {
+                self.0
+            }
+        }
+    };
+}
+
+// need to truncate for some fork-choice algorithms
+macro_rules! impl_into_u32 {
+    ($main: ident) => {
+        impl Into<u32> for $main {
+            fn into(self) -> u32 {
+                self.0 as u32
+            }
+        }
+
+        impl $main {
+            pub fn as_u32(&self) -> u32 {
+                self.0 as u32
+            }
+        }
+    };
+}
+
+macro_rules! impl_from_into_usize {
+    ($main: ident) => {
+        impl From<usize> for $main {
+            fn from(n: usize) -> $main {
+                $main(n as u64)
+            }
+        }
+
+        impl Into<usize> for $main {
+            fn into(self) -> usize {
+                self.0 as usize
+            }
+        }
+
+        impl $main {
+            pub fn as_usize(&self) -> usize {
+                self.0 as usize
+            }
+        }
+    };
+}
+
+macro_rules! impl_math_between {
+    ($main: ident, $other: ident) => {
+        impl PartialOrd<$other> for $main {
+            /// Utilizes `partial_cmp` on the underlying `u64`.
+            fn partial_cmp(&self, other: &$other) -> Option<Ordering> {
+                Some(self.0.cmp(&(*other).into()))
+            }
+        }
+
+        impl PartialEq<$other> for $main {
+            fn eq(&self, other: &$other) -> bool {
+                let other: u64 = (*other).into();
+                self.0 == other
+            }
+        }
+
+        impl Add<$other> for $main {
+            type Output = $main;
+
+            fn add(self, other: $other) -> $main {
+                $main::from(self.0.saturating_add(other.into()))
+            }
+        }
+
+        impl AddAssign<$other> for $main {
+            fn add_assign(&mut self, other: $other) {
+                self.0 = self.0.saturating_add(other.into());
+            }
+        }
+
+        impl Sub<$other> for $main {
+            type Output = $main;
+
+            fn sub(self, other: $other) -> $main {
+                $main::from(self.0.saturating_sub(other.into()))
+            }
+        }
+
+        impl SubAssign<$other> for $main {
+            fn sub_assign(&mut self, other: $other) {
+                self.0 = self.0.saturating_sub(other.into());
+            }
+        }
+
+        impl Mul<$other> for $main {
+            type Output = $main;
+
+            fn mul(self, rhs: $other) -> $main {
+                let rhs: u64 = rhs.into();
+                $main::from(self.0.saturating_mul(rhs))
+            }
+        }
+
+        impl MulAssign<$other> for $main {
+            fn mul_assign(&mut self, rhs: $other) {
+                let rhs: u64 = rhs.into();
+                self.0 = self.0.saturating_mul(rhs)
+            }
+        }
+
+        impl Div<$other> for $main {
+            type Output = $main;
+
+            fn div(self, rhs: $other) -> $main {
+                let rhs: u64 = rhs.into();
+                if rhs == 0 {
+                    panic!("Cannot divide by zero-valued Slot/Epoch")
+                }
+                $main::from(self.0 / rhs)
+            }
+        }
+
+        impl DivAssign<$other> for $main {
+            fn div_assign(&mut self, rhs: $other) {
+                let rhs: u64 = rhs.into();
+                if rhs == 0 {
+                    panic!("Cannot divide by zero-valued Slot/Epoch")
+                }
+                self.0 = self.0 / rhs
+            }
+        }
+
+        impl Rem<$other> for $main {
+            type Output = $main;
+
+            fn rem(self, modulus: $other) -> $main {
+                let modulus: u64 = modulus.into();
+                $main::from(self.0 % modulus)
+            }
+        }
+    };
+}
+
+macro_rules! impl_math {
+    ($type: ident) => {
+        impl $type {
+            pub fn saturating_sub<T: Into<$type>>(&self, other: T) -> $type {
+                *self - other.into()
+            }
+
+            pub fn saturating_add<T: Into<$type>>(&self, other: T) -> $type {
+                *self + other.into()
+            }
+
+            pub fn checked_div<T: Into<$type>>(&self, rhs: T) -> Option<$type> {
+                let rhs: $type = rhs.into();
+                if rhs == 0 {
+                    None
+                } else {
+                    Some(*self / rhs)
+                }
+            }
+
+            pub fn is_power_of_two(&self) -> bool {
+                self.0.is_power_of_two()
+            }
+        }
+
+        impl Ord for $type {
+            fn cmp(&self, other: &$type) -> Ordering {
+                let other: u64 = (*other).into();
+                self.0.cmp(&other)
+            }
+        }
+    };
+}
+
+macro_rules! impl_display {
+    ($type: ident) => {
+        impl fmt::Display for $type {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "{}", self.0)
+            }
+        }
+
+        impl slog::Value for $type {
+            fn serialize(
+                &self,
+                record: &slog::Record,
+                key: slog::Key,
+                serializer: &mut slog::Serializer,
+            ) -> slog::Result {
+                self.0.serialize(record, key, serializer)
+            }
+        }
+    };
+}
+
+macro_rules! impl_ssz {
+    ($type: ident) => {
+        impl Encodable for $type {
+            fn ssz_append(&self, s: &mut SszStream) {
+                s.append(&self.0);
+            }
+        }
+
+        impl Decodable for $type {
+            fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+                let (value, i) = <_>::ssz_decode(bytes, i)?;
+
+                Ok(($type(value), i))
+            }
+        }
+
+        impl TreeHash for $type {
+            fn hash_tree_root(&self) -> Vec<u8> {
+                let mut result: Vec<u8> = vec![];
+                result.append(&mut self.0.hash_tree_root());
+                hash(&result)
+            }
+        }
+
+        impl<T: RngCore> TestRandom<T> for $type {
+            fn random_for_test(rng: &mut T) -> Self {
+                $type::from(u64::random_for_test(rng))
+            }
+        }
+    };
+}
+
+macro_rules! impl_hash {
+    ($type: ident) => {
+        // Implemented to stop clippy lint:
+        // https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
+        impl Hash for $type {
+            fn hash<H: Hasher>(&self, state: &mut H) {
+                ssz_encode(self).hash(state)
+            }
+        }
+    };
+}
+
+macro_rules! impl_common {
+    ($type: ident) => {
+        impl_from_into_u64!($type);
+        impl_from_into_usize!($type);
+        impl_math_between!($type, $type);
+        impl_math_between!($type, u64);
+        impl_math!($type);
+        impl_display!($type);
+        impl_ssz!($type);
+        impl_hash!($type);
+    };
+}
+
+/// Beacon block slot.
+#[derive(Eq, Debug, Clone, Copy, Default, Serialize)]
+pub struct Slot(u64);
+
+/// Beacon block height, effectively `Slot/GENESIS_START_BLOCK`.
+#[derive(Eq, Debug, Clone, Copy, Default, Serialize)]
+pub struct Height(u64);
+
+/// Beacon Epoch, effectively `Slot / EPOCH_LENGTH`.
+#[derive(Eq, Debug, Clone, Copy, Default, Serialize)]
+pub struct Epoch(u64);
+
+impl_common!(Slot);
+impl_common!(Height);
+impl_into_u32!(Height); // height can be converted to u32
+impl_common!(Epoch);
+
+impl Slot {
+    pub fn new(slot: u64) -> Slot {
+        Slot(slot)
+    }
+
+    pub fn epoch(self, epoch_length: u64) -> Epoch {
+        Epoch::from(self.0 / epoch_length)
+    }
+
+    pub fn height(self, genesis_slot: Slot) -> Height {
+        Height::from(self.0.saturating_sub(genesis_slot.as_u64()))
+    }
+
+    pub fn max_value() -> Slot {
+        Slot(u64::max_value())
+    }
+}
+
+impl Height {
+    pub fn new(slot: u64) -> Height {
+        Height(slot)
+    }
+
+    pub fn slot(self, genesis_slot: Slot) -> Slot {
+        Slot::from(self.0.saturating_add(genesis_slot.as_u64()))
+    }
+
+    pub fn epoch(self, genesis_slot: u64, epoch_length: u64) -> Epoch {
+        Epoch::from(self.0.saturating_add(genesis_slot) / epoch_length)
+    }
+
+    pub fn max_value() -> Height {
+        Height(u64::max_value())
+    }
+}
+
+impl Epoch {
+    pub fn new(slot: u64) -> Epoch {
+        Epoch(slot)
+    }
+
+    pub fn max_value() -> Epoch {
+        Epoch(u64::max_value())
+    }
+
+    pub fn start_slot(self, epoch_length: u64) -> Slot {
+        Slot::from(self.0.saturating_mul(epoch_length))
+    }
+
+    pub fn end_slot(self, epoch_length: u64) -> Slot {
+        Slot::from(
+            self.0
+                .saturating_add(1)
+                .saturating_mul(epoch_length)
+                .saturating_sub(1),
+        )
+    }
+
+    pub fn slot_iter(&self, epoch_length: u64) -> SlotIter {
+        SlotIter {
+            current: self.start_slot(epoch_length),
+            epoch: self,
+            epoch_length,
+        }
+    }
+}
+
+pub struct SlotIter<'a> {
+    current: Slot,
+    epoch: &'a Epoch,
+    epoch_length: u64,
+}
+
+impl<'a> Iterator for SlotIter<'a> {
+    type Item = Slot;
+
+    fn next(&mut self) -> Option<Slot> {
+        if self.current == self.epoch.end_slot(self.epoch_length) {
+            None
+        } else {
+            let previous = self.current;
+            self.current += 1;
+            Some(previous)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! new_tests {
+        ($type: ident) => {
+            #[test]
+            fn new() {
+                assert_eq!($type(0), $type::new(0));
+                assert_eq!($type(3), $type::new(3));
+                assert_eq!($type(u64::max_value()), $type::new(u64::max_value()));
+            }
+        };
+    }
+
+    macro_rules! from_into_tests {
+        ($type: ident, $other: ident) => {
+            #[test]
+            fn into() {
+                let x: $other = $type(0).into();
+                assert_eq!(x, 0);
+
+                let x: $other = $type(3).into();
+                assert_eq!(x, 3);
+
+                let x: $other = $type(u64::max_value()).into();
+                // Note: this will fail on 32 bit systems. This is expected as we don't have a proper
+                // 32-bit system strategy in place.
+                assert_eq!(x, $other::max_value());
+            }
+
+            #[test]
+            fn from() {
+                assert_eq!($type(0), $type::from(0_u64));
+                assert_eq!($type(3), $type::from(3_u64));
+                assert_eq!($type(u64::max_value()), $type::from($other::max_value()));
+            }
+        };
+    }
+
+    macro_rules! math_between_tests {
+        ($type: ident, $other: ident) => {
+            #[test]
+            fn partial_ord() {
+                let assert_partial_ord = |a: u64, partial_ord: Ordering, b: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a).partial_cmp(&other), Some(partial_ord));
+                };
+
+                assert_partial_ord(1, Ordering::Less, 2);
+                assert_partial_ord(2, Ordering::Greater, 1);
+                assert_partial_ord(0, Ordering::Less, u64::max_value());
+                assert_partial_ord(u64::max_value(), Ordering::Greater, 0);
+            }
+
+            #[test]
+            fn partial_eq() {
+                let assert_partial_eq = |a: u64, b: u64, is_equal: bool| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a).eq(&other), is_equal);
+                };
+
+                assert_partial_eq(0, 0, true);
+                assert_partial_eq(0, 1, false);
+                assert_partial_eq(1, 0, false);
+                assert_partial_eq(1, 1, true);
+
+                assert_partial_eq(u64::max_value(), u64::max_value(), true);
+                assert_partial_eq(0, u64::max_value(), false);
+                assert_partial_eq(u64::max_value(), 0, false);
+            }
+
+            #[test]
+            fn add_and_add_assign() {
+                let assert_add = |a: u64, b: u64, result: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a) + other, $type(result));
+
+                    let mut add_assigned = $type(a);
+                    add_assigned += other;
+
+                    assert_eq!(add_assigned, $type(result));
+                };
+
+                assert_add(0, 1, 1);
+                assert_add(1, 0, 1);
+                assert_add(1, 2, 3);
+                assert_add(2, 1, 3);
+                assert_add(7, 7, 14);
+
+                // Addition should be saturating.
+                assert_add(u64::max_value(), 1, u64::max_value());
+                assert_add(u64::max_value(), u64::max_value(), u64::max_value());
+            }
+
+            #[test]
+            fn sub_and_sub_assign() {
+                let assert_sub = |a: u64, b: u64, result: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a) - other, $type(result));
+
+                    let mut sub_assigned = $type(a);
+                    sub_assigned -= other;
+
+                    assert_eq!(sub_assigned, $type(result));
+                };
+
+                assert_sub(1, 0, 1);
+                assert_sub(2, 1, 1);
+                assert_sub(14, 7, 7);
+                assert_sub(u64::max_value(), 1, u64::max_value() - 1);
+                assert_sub(u64::max_value(), u64::max_value(), 0);
+
+                // Subtraction should be saturating
+                assert_sub(0, 1, 0);
+                assert_sub(1, 2, 0);
+            }
+
+            #[test]
+            fn mul_and_mul_assign() {
+                let assert_mul = |a: u64, b: u64, result: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a) * other, $type(result));
+
+                    let mut mul_assigned = $type(a);
+                    mul_assigned *= other;
+
+                    assert_eq!(mul_assigned, $type(result));
+                };
+
+                assert_mul(2, 2, 4);
+                assert_mul(1, 2, 2);
+                assert_mul(0, 2, 0);
+
+                // Multiplication should be saturating.
+                assert_mul(u64::max_value(), 2, u64::max_value());
+            }
+
+            #[test]
+            fn div_and_div_assign() {
+                let assert_div = |a: u64, b: u64, result: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a) / other, $type(result));
+
+                    let mut div_assigned = $type(a);
+                    div_assigned /= other;
+
+                    assert_eq!(div_assigned, $type(result));
+                };
+
+                assert_div(0, 2, 0);
+                assert_div(2, 2, 1);
+                assert_div(100, 50, 2);
+                assert_div(128, 2, 64);
+                assert_div(u64::max_value(), 2, 2_u64.pow(63) - 1);
+            }
+
+            #[test]
+            #[should_panic]
+            fn div_panics_with_divide_by_zero() {
+                let other: $other = $type(0).into();
+                let _ = $type(2) / other;
+            }
+
+            #[test]
+            #[should_panic]
+            fn div_assign_panics_with_divide_by_zero() {
+                let other: $other = $type(0).into();
+                let mut assigned = $type(2);
+                assigned /= other;
+            }
+
+            #[test]
+            fn rem() {
+                let assert_rem = |a: u64, b: u64, result: u64| {
+                    let other: $other = $type(b).into();
+                    assert_eq!($type(a) % other, $type(result));
+                };
+
+                assert_rem(3, 2, 1);
+                assert_rem(40, 2, 0);
+                assert_rem(10, 100, 10);
+                assert_rem(302042, 3293, 2379);
+            }
+        };
+    }
+
+    macro_rules! math_tests {
+        ($type: ident) => {
+            #[test]
+            fn saturating_sub() {
+                let assert_saturating_sub = |a: u64, b: u64, result: u64| {
+                    assert_eq!($type(a).saturating_sub($type(b)), $type(result));
+                };
+
+                assert_saturating_sub(1, 0, 1);
+                assert_saturating_sub(2, 1, 1);
+                assert_saturating_sub(14, 7, 7);
+                assert_saturating_sub(u64::max_value(), 1, u64::max_value() - 1);
+                assert_saturating_sub(u64::max_value(), u64::max_value(), 0);
+
+                // Subtraction should be saturating
+                assert_saturating_sub(0, 1, 0);
+                assert_saturating_sub(1, 2, 0);
+            }
+
+            #[test]
+            fn saturating_add() {
+                let assert_saturating_add = |a: u64, b: u64, result: u64| {
+                    assert_eq!($type(a).saturating_add($type(b)), $type(result));
+                };
+
+                assert_saturating_add(0, 1, 1);
+                assert_saturating_add(1, 0, 1);
+                assert_saturating_add(1, 2, 3);
+                assert_saturating_add(2, 1, 3);
+                assert_saturating_add(7, 7, 14);
+
+                // Addition should be saturating.
+                assert_saturating_add(u64::max_value(), 1, u64::max_value());
+                assert_saturating_add(u64::max_value(), u64::max_value(), u64::max_value());
+            }
+
+            #[test]
+            fn checked_div() {
+                let assert_checked_div = |a: u64, b: u64, result: Option<u64>| {
+                    let division_result_as_u64 = match $type(a).checked_div($type(b)) {
+                        None => None,
+                        Some(val) => Some(val.as_u64()),
+                    };
+                    assert_eq!(division_result_as_u64, result);
+                };
+
+                assert_checked_div(0, 2, Some(0));
+                assert_checked_div(2, 2, Some(1));
+                assert_checked_div(100, 50, Some(2));
+                assert_checked_div(128, 2, Some(64));
+                assert_checked_div(u64::max_value(), 2, Some(2_u64.pow(63) - 1));
+
+                assert_checked_div(2, 0, None);
+                assert_checked_div(0, 0, None);
+                assert_checked_div(u64::max_value(), 0, None);
+            }
+
+            #[test]
+            fn is_power_of_two() {
+                let assert_is_power_of_two = |a: u64, result: bool| {
+                    assert_eq!(
+                        $type(a).is_power_of_two(),
+                        result,
+                        "{}.is_power_of_two() != {}",
+                        a,
+                        result
+                    );
+                };
+
+                assert_is_power_of_two(0, false);
+                assert_is_power_of_two(1, true);
+                assert_is_power_of_two(2, true);
+                assert_is_power_of_two(3, false);
+                assert_is_power_of_two(4, true);
+
+                assert_is_power_of_two(2_u64.pow(4), true);
+                assert_is_power_of_two(u64::max_value(), false);
+            }
+
+            #[test]
+            fn ord() {
+                let assert_ord = |a: u64, ord: Ordering, b: u64| {
+                    assert_eq!($type(a).cmp(&$type(b)), ord);
+                };
+
+                assert_ord(1, Ordering::Less, 2);
+                assert_ord(2, Ordering::Greater, 1);
+                assert_ord(0, Ordering::Less, u64::max_value());
+                assert_ord(u64::max_value(), Ordering::Greater, 0);
+            }
+        };
+    }
+
+    macro_rules! ssz_tests {
+        ($type: ident) => {
+            #[test]
+            pub fn test_ssz_round_trip() {
+                let mut rng = XorShiftRng::from_seed([42; 16]);
+                let original = $type::random_for_test(&mut rng);
+
+                let bytes = ssz_encode(&original);
+                let (decoded, _) = $type::ssz_decode(&bytes, 0).unwrap();
+
+                assert_eq!(original, decoded);
+            }
+
+            #[test]
+            pub fn test_hash_tree_root() {
+                let mut rng = XorShiftRng::from_seed([42; 16]);
+                let original = $type::random_for_test(&mut rng);
+
+                let result = original.hash_tree_root();
+
+                assert_eq!(result.len(), 32);
+                // TODO: Add further tests
+                // https://github.com/sigp/lighthouse/issues/170
+            }
+        };
+    }
+
+    macro_rules! all_tests {
+        ($type: ident) => {
+            new_tests!($type);
+            math_between_tests!($type, $type);
+            math_tests!($type);
+            ssz_tests!($type);
+
+            mod u64_tests {
+                use super::*;
+
+                from_into_tests!($type, u64);
+                math_between_tests!($type, u64);
+
+                #[test]
+                pub fn as_64() {
+                    let x = $type(0).as_u64();
+                    assert_eq!(x, 0);
+
+                    let x = $type(3).as_u64();
+                    assert_eq!(x, 3);
+
+                    let x = $type(u64::max_value()).as_u64();
+                    assert_eq!(x, u64::max_value());
+                }
+            }
+
+            mod usize_tests {
+                use super::*;
+
+                from_into_tests!($type, usize);
+
+                #[test]
+                pub fn as_usize() {
+                    let x = $type(0).as_usize();
+                    assert_eq!(x, 0);
+
+                    let x = $type(3).as_usize();
+                    assert_eq!(x, 3);
+
+                    let x = $type(u64::max_value()).as_usize();
+                    assert_eq!(x, usize::max_value());
+                }
+            }
+        };
+    }
+
+    #[cfg(test)]
+    mod slot_tests {
+        use super::*;
+        use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+        use ssz::ssz_encode;
+
+        all_tests!(Slot);
+    }
+
+    #[cfg(test)]
+    mod epoch_tests {
+        use super::*;
+        use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+        use ssz::ssz_encode;
+
+        all_tests!(Epoch);
+    }
+}

eth2/types/src/spec/foundation.rs

@@ -0,0 +1,111 @@
+use crate::{Address, ChainSpec, Epoch, Hash256, Signature, Slot};
+
+const GWEI: u64 = 1_000_000_000;
+
+impl ChainSpec {
+    /// Returns a `ChainSpec` compatible with the specification from Ethereum Foundation.
+    ///
+    /// Of course, the actual foundation specs are unknown at this point so these are just a rough
+    /// estimate.
+    ///
+    /// Spec v0.2.0
+    pub fn foundation() -> Self {
+        let genesis_slot = Slot::new(2_u64.pow(19));
+        let epoch_length = 64;
+        let genesis_epoch = genesis_slot.epoch(epoch_length);
+
+        Self {
+            /*
+             * Misc
+             */
+            shard_count: 1_024,
+            target_committee_size: 128,
+            max_balance_churn_quotient: 32,
+            beacon_chain_shard_number: u64::max_value(),
+            max_indices_per_slashable_vote: 4_096,
+            max_withdrawals_per_epoch: 4,
+            shuffle_round_count: 90,
+
+            /*
+             *  Deposit contract
+             */
+            deposit_contract_address: Address::zero(),
+            deposit_contract_tree_depth: 32,
+
+            /*
+             *  Gwei values
+             */
+            min_deposit_amount: u64::pow(2, 0) * GWEI,
+            max_deposit_amount: u64::pow(2, 5) * GWEI,
+            fork_choice_balance_increment: u64::pow(2, 0) * GWEI,
+            ejection_balance: u64::pow(2, 4) * GWEI,
+
+            /*
+             * Initial Values
+             */
+            genesis_fork_version: 0,
+            genesis_slot: Slot::new(2_u64.pow(19)),
+            genesis_epoch,
+            genesis_start_shard: 0,
+            far_future_epoch: Epoch::new(u64::max_value()),
+            zero_hash: Hash256::zero(),
+            empty_signature: Signature::empty_signature(),
+            bls_withdrawal_prefix_byte: 0,
+
+            /*
+             * Time parameters
+             */
+            slot_duration: 6,
+            min_attestation_inclusion_delay: 4,
+            epoch_length,
+            seed_lookahead: Epoch::new(1),
+            entry_exit_delay: 4,
+            eth1_data_voting_period: 16,
+            min_validator_withdrawal_epochs: Epoch::new(256),
+
+            /*
+             * State list lengths
+             */
+            latest_block_roots_length: 8_192,
+            latest_randao_mixes_length: 8_192,
+            latest_index_roots_length: 8_192,
+            latest_penalized_exit_length: 8_192,
+
+            /*
+             * Reward and penalty quotients
+             */
+            base_reward_quotient: 32,
+            whistleblower_reward_quotient: 512,
+            includer_reward_quotient: 8,
+            inactivity_penalty_quotient: 16_777_216,
+
+            /*
+             * Max operations per block
+             */
+            max_proposer_slashings: 16,
+            max_attester_slashings: 1,
+            max_attestations: 128,
+            max_deposits: 16,
+            max_exits: 16,
+
+            /*
+             * Signature domains
+             */
+            domain_deposit: 0,
+            domain_attestation: 1,
+            domain_proposal: 2,
+            domain_exit: 3,
+            domain_randao: 4,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_foundation_spec_can_be_constructed() {
+        let _ = ChainSpec::foundation();
+    }
+}

eth2/types/src/spec/mod.rs

@@ -0,0 +1,92 @@
+mod foundation;
+
+use crate::{Address, Epoch, Hash256, Slot};
+use bls::Signature;
+
+/// Holds all the "constants" for a BeaconChain.
+///
+/// Spec v0.2.0
+#[derive(PartialEq, Debug, Clone)]
+pub struct ChainSpec {
+    /*
+     * Misc
+     */
+    pub shard_count: u64,
+    pub target_committee_size: u64,
+    pub max_balance_churn_quotient: u64,
+    pub beacon_chain_shard_number: u64,
+    pub max_indices_per_slashable_vote: u64,
+    pub max_withdrawals_per_epoch: u64,
+    pub shuffle_round_count: u64,
+
+    /*
+     *  Deposit contract
+     */
+    pub deposit_contract_address: Address,
+    pub deposit_contract_tree_depth: u64,
+
+    /*
+     *  Gwei values
+     */
+    pub min_deposit_amount: u64,
+    pub max_deposit_amount: u64,
+    pub fork_choice_balance_increment: u64,
+    pub ejection_balance: u64,
+
+    /*
+     * Initial Values
+     */
+    pub genesis_fork_version: u64,
+    pub genesis_slot: Slot,
+    pub genesis_epoch: Epoch,
+    pub genesis_start_shard: u64,
+    pub far_future_epoch: Epoch,
+    pub zero_hash: Hash256,
+    pub empty_signature: Signature,
+    pub bls_withdrawal_prefix_byte: u8,
+
+    /*
+     * Time parameters
+     */
+    pub slot_duration: u64,
+    pub min_attestation_inclusion_delay: u64,
+    pub epoch_length: u64,
+    pub seed_lookahead: Epoch,
+    pub entry_exit_delay: u64,
+    pub eth1_data_voting_period: u64,
+    pub min_validator_withdrawal_epochs: Epoch,
+
+    /*
+     * State list lengths
+     */
+    pub latest_block_roots_length: usize,
+    pub latest_randao_mixes_length: usize,
+    pub latest_index_roots_length: usize,
+    pub latest_penalized_exit_length: usize,
+
+    /*
+     * Reward and penalty quotients
+     */
+    pub base_reward_quotient: u64,
+    pub whistleblower_reward_quotient: u64,
+    pub includer_reward_quotient: u64,
+    pub inactivity_penalty_quotient: u64,
+
+    /*
+     * Max operations per block
+     */
+    pub max_proposer_slashings: u64,
+    pub max_attester_slashings: u64,
+    pub max_attestations: u64,
+    pub max_deposits: u64,
+    pub max_exits: u64,
+
+    /*
+     * Signature domains
+     */
+    pub domain_deposit: u64,
+    pub domain_attestation: u64,
+    pub domain_proposal: u64,
+    pub domain_exit: u64,
+    pub domain_randao: u64,
+}

eth2/types/src/test_utils/address.rs

@@ -0,0 +1,11 @@
+use super::TestRandom;
+use crate::Address;
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for Address {
+    fn random_for_test(rng: &mut T) -> Self {
+        let mut key_bytes = vec![0; 20];
+        rng.fill_bytes(&mut key_bytes);
+        Address::from(&key_bytes[..])
+    }
+}

eth2/types/src/test_utils/aggregate_signature.rs

@@ -0,0 +1,12 @@
+use super::TestRandom;
+use bls::{AggregateSignature, Signature};
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for AggregateSignature {
+    fn random_for_test(rng: &mut T) -> Self {
+        let signature = Signature::random_for_test(rng);
+        let mut aggregate_signature = AggregateSignature::new();
+        aggregate_signature.add(&signature);
+        aggregate_signature
+    }
+}

eth2/types/src/test_utils/bitfield.rs

@@ -0,0 +1,11 @@
+use super::super::Bitfield;
+use super::TestRandom;
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for Bitfield {
+    fn random_for_test(rng: &mut T) -> Self {
+        let mut raw_bytes = vec![0; 32];
+        rng.fill_bytes(&mut raw_bytes);
+        Bitfield::from_bytes(&raw_bytes)
+    }
+}

eth2/types/src/test_utils/hash256.rs

@@ -0,0 +1,11 @@
+use super::TestRandom;
+use crate::Hash256;
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for Hash256 {
+    fn random_for_test(rng: &mut T) -> Self {
+        let mut key_bytes = vec![0; 32];
+        rng.fill_bytes(&mut key_bytes);
+        Hash256::from(&key_bytes[..])
+    }
+}

eth2/types/src/test_utils/mod.rs

@@ -0,0 +1,49 @@
+use rand::RngCore;
+
+pub use rand::{prng::XorShiftRng, SeedableRng};
+
+pub mod address;
+pub mod aggregate_signature;
+pub mod bitfield;
+pub mod hash256;
+pub mod public_key;
+pub mod secret_key;
+pub mod signature;
+
+pub trait TestRandom<T>
+where
+    T: RngCore,
+{
+    fn random_for_test(rng: &mut T) -> Self;
+}
+
+impl<T: RngCore> TestRandom<T> for u64 {
+    fn random_for_test(rng: &mut T) -> Self {
+        rng.next_u64()
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for u32 {
+    fn random_for_test(rng: &mut T) -> Self {
+        rng.next_u32()
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for usize {
+    fn random_for_test(rng: &mut T) -> Self {
+        rng.next_u32() as usize
+    }
+}
+
+impl<T: RngCore, U> TestRandom<T> for Vec<U>
+where
+    U: TestRandom<T>,
+{
+    fn random_for_test(rng: &mut T) -> Self {
+        vec![
+            <U>::random_for_test(rng),
+            <U>::random_for_test(rng),
+            <U>::random_for_test(rng),
+        ]
+    }
+}

eth2/types/src/test_utils/public_key.rs

@@ -0,0 +1,10 @@
+use super::TestRandom;
+use bls::{PublicKey, SecretKey};
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for PublicKey {
+    fn random_for_test(rng: &mut T) -> Self {
+        let secret_key = SecretKey::random_for_test(rng);
+        PublicKey::from_secret_key(&secret_key)
+    }
+}

eth2/types/src/test_utils/secret_key.rs

@@ -0,0 +1,19 @@
+use super::TestRandom;
+use bls::SecretKey;
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for SecretKey {
+    fn random_for_test(rng: &mut T) -> Self {
+        let mut key_bytes = vec![0; 48];
+        rng.fill_bytes(&mut key_bytes);
+        /*
+         * An `unreachable!` is used here as there's no reason why you cannot constuct a key from a
+         * fixed-length byte slice. Also, this should only be used during testing so a panic is
+         * acceptable.
+         */
+        match SecretKey::from_bytes(&key_bytes) {
+            Ok(key) => key,
+            Err(_) => unreachable!(),
+        }
+    }
+}

eth2/types/src/test_utils/signature.rs

@@ -0,0 +1,13 @@
+use super::TestRandom;
+use bls::{SecretKey, Signature};
+use rand::RngCore;
+
+impl<T: RngCore> TestRandom<T> for Signature {
+    fn random_for_test(rng: &mut T) -> Self {
+        let secret_key = SecretKey::random_for_test(rng);
+        let mut message = vec![0; 32];
+        rng.fill_bytes(&mut message);
+
+        Signature::new(&message, &secret_key)
+    }
+}

eth2/types/src/validator.rs

@@ -0,0 +1,203 @@
+use crate::{test_utils::TestRandom, Epoch, Hash256, PublicKey};
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+const STATUS_FLAG_INITIATED_EXIT: u8 = 1;
+const STATUS_FLAG_WITHDRAWABLE: u8 = 2;
+
+#[derive(Debug, PartialEq, Clone, Copy, Serialize)]
+pub enum StatusFlags {
+    InitiatedExit,
+    Withdrawable,
+}
+
+struct StatusFlagsDecodeError;
+
+impl From<StatusFlagsDecodeError> for DecodeError {
+    fn from(_: StatusFlagsDecodeError) -> DecodeError {
+        DecodeError::Invalid
+    }
+}
+
+/// Handles the serialization logic for the `status_flags` field of the `Validator`.
+fn status_flag_to_byte(flag: Option<StatusFlags>) -> u8 {
+    if let Some(flag) = flag {
+        match flag {
+            StatusFlags::InitiatedExit => STATUS_FLAG_INITIATED_EXIT,
+            StatusFlags::Withdrawable => STATUS_FLAG_WITHDRAWABLE,
+        }
+    } else {
+        0
+    }
+}
+
+/// Handles the deserialization logic for the `status_flags` field of the `Validator`.
+fn status_flag_from_byte(flag: u8) -> Result<Option<StatusFlags>, StatusFlagsDecodeError> {
+    match flag {
+        0 => Ok(None),
+        1 => Ok(Some(StatusFlags::InitiatedExit)),
+        2 => Ok(Some(StatusFlags::Withdrawable)),
+        _ => Err(StatusFlagsDecodeError),
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct Validator {
+    pub pubkey: PublicKey,
+    pub withdrawal_credentials: Hash256,
+    pub activation_epoch: Epoch,
+    pub exit_epoch: Epoch,
+    pub withdrawal_epoch: Epoch,
+    pub penalized_epoch: Epoch,
+    pub status_flags: Option<StatusFlags>,
+}
+
+impl Validator {
+    /// This predicate indicates if the validator represented by this record is considered "active" at `slot`.
+    pub fn is_active_at(&self, slot: Epoch) -> bool {
+        self.activation_epoch <= slot && slot < self.exit_epoch
+    }
+}
+
+impl Default for Validator {
+    /// Yields a "default" `Validator`. Primarily used for testing.
+    fn default() -> Self {
+        Self {
+            pubkey: PublicKey::default(),
+            withdrawal_credentials: Hash256::default(),
+            activation_epoch: Epoch::from(std::u64::MAX),
+            exit_epoch: Epoch::from(std::u64::MAX),
+            withdrawal_epoch: Epoch::from(std::u64::MAX),
+            penalized_epoch: Epoch::from(std::u64::MAX),
+            status_flags: None,
+        }
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for StatusFlags {
+    fn random_for_test(rng: &mut T) -> Self {
+        let options = vec![StatusFlags::InitiatedExit, StatusFlags::Withdrawable];
+        options[(rng.next_u32() as usize) % options.len()]
+    }
+}
+
+impl Encodable for Validator {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.pubkey);
+        s.append(&self.withdrawal_credentials);
+        s.append(&self.activation_epoch);
+        s.append(&self.exit_epoch);
+        s.append(&self.withdrawal_epoch);
+        s.append(&self.penalized_epoch);
+        s.append(&status_flag_to_byte(self.status_flags));
+    }
+}
+
+impl Decodable for Validator {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (pubkey, i) = <_>::ssz_decode(bytes, i)?;
+        let (withdrawal_credentials, i) = <_>::ssz_decode(bytes, i)?;
+        let (activation_epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (exit_epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (withdrawal_epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (penalized_epoch, i) = <_>::ssz_decode(bytes, i)?;
+        let (status_flags_byte, i): (u8, usize) = <_>::ssz_decode(bytes, i)?;
+
+        let status_flags = status_flag_from_byte(status_flags_byte)?;
+
+        Ok((
+            Self {
+                pubkey,
+                withdrawal_credentials,
+                activation_epoch,
+                exit_epoch,
+                withdrawal_epoch,
+                penalized_epoch,
+                status_flags,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for Validator {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.pubkey.hash_tree_root());
+        result.append(&mut self.withdrawal_credentials.hash_tree_root());
+        result.append(&mut self.activation_epoch.hash_tree_root());
+        result.append(&mut self.exit_epoch.hash_tree_root());
+        result.append(&mut self.withdrawal_epoch.hash_tree_root());
+        result.append(&mut self.penalized_epoch.hash_tree_root());
+        result.append(&mut u64::from(status_flag_to_byte(self.status_flags)).hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for Validator {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            pubkey: <_>::random_for_test(rng),
+            withdrawal_credentials: <_>::random_for_test(rng),
+            activation_epoch: <_>::random_for_test(rng),
+            exit_epoch: <_>::random_for_test(rng),
+            withdrawal_epoch: <_>::random_for_test(rng),
+            penalized_epoch: <_>::random_for_test(rng),
+            status_flags: Some(<_>::random_for_test(rng)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Validator::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    fn test_validator_can_be_active() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let mut validator = Validator::random_for_test(&mut rng);
+
+        let activation_epoch = u64::random_for_test(&mut rng);
+        let exit_epoch = activation_epoch + 234;
+
+        validator.activation_epoch = Epoch::from(activation_epoch);
+        validator.exit_epoch = Epoch::from(exit_epoch);
+
+        for slot in (activation_epoch - 100)..(exit_epoch + 100) {
+            let slot = Epoch::from(slot);
+            if slot < activation_epoch {
+                assert!(!validator.is_active_at(slot));
+            } else if slot >= exit_epoch {
+                assert!(!validator.is_active_at(slot));
+            } else {
+                assert!(validator.is_active_at(slot));
+            }
+        }
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Validator::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}

eth2/types/src/validator_registry.rs

@@ -0,0 +1,172 @@
+/// Contains logic to manipulate a `&[Validator]`.
+/// For now, we avoid defining a newtype and just have flat functions here.
+use super::validator::*;
+use crate::Epoch;
+
+/// Given an indexed sequence of `validators`, return the indices corresponding to validators that are active at `epoch`.
+pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> Vec<usize> {
+    validators
+        .iter()
+        .enumerate()
+        .filter_map(|(index, validator)| {
+            if validator.is_active_at(epoch) {
+                Some(index)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+
+    #[test]
+    fn can_get_empty_active_validator_indices() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+
+        let validators = vec![];
+        let some_epoch = Epoch::random_for_test(&mut rng);
+        let indices = get_active_validator_indices(&validators, some_epoch);
+        assert_eq!(indices, vec![]);
+    }
+
+    #[test]
+    fn can_get_no_active_validator_indices() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let mut validators = vec![];
+        let count_validators = 10;
+        for _ in 0..count_validators {
+            validators.push(Validator::default())
+        }
+
+        let some_epoch = Epoch::random_for_test(&mut rng);
+        let indices = get_active_validator_indices(&validators, some_epoch);
+        assert_eq!(indices, vec![]);
+    }
+
+    #[test]
+    fn can_get_all_active_validator_indices() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let count_validators = 10;
+        let some_epoch = Epoch::random_for_test(&mut rng);
+
+        let mut validators = (0..count_validators)
+            .into_iter()
+            .map(|_| {
+                let mut validator = Validator::default();
+
+                let activation_offset = u64::random_for_test(&mut rng);
+                let exit_offset = u64::random_for_test(&mut rng);
+
+                validator.activation_epoch = some_epoch - activation_offset;
+                validator.exit_epoch = some_epoch + exit_offset;
+
+                validator
+            })
+            .collect::<Vec<_>>();
+
+        // test boundary condition by ensuring that at least one validator in the list just activated
+        if let Some(validator) = validators.get_mut(0) {
+            validator.activation_epoch = some_epoch;
+        }
+
+        let indices = get_active_validator_indices(&validators, some_epoch);
+        assert_eq!(
+            indices,
+            (0..count_validators).into_iter().collect::<Vec<_>>()
+        );
+    }
+
+    fn set_validators_to_default_entry_exit(validators: &mut [Validator]) {
+        for validator in validators.iter_mut() {
+            validator.activation_epoch = Epoch::max_value();
+            validator.exit_epoch = Epoch::max_value();
+        }
+    }
+
+    // sets all `validators` to be active as of some epoch prior to `epoch`. returns the activation epoch.
+    fn set_validators_to_activated(validators: &mut [Validator], epoch: Epoch) -> Epoch {
+        let activation_epoch = epoch - 10;
+        for validator in validators.iter_mut() {
+            validator.activation_epoch = activation_epoch;
+        }
+        activation_epoch
+    }
+
+    // sets all `validators` to be exited as of some epoch before `epoch`.
+    fn set_validators_to_exited(
+        validators: &mut [Validator],
+        epoch: Epoch,
+        activation_epoch: Epoch,
+    ) {
+        assert!(activation_epoch < epoch);
+        let mut exit_epoch = activation_epoch + 10;
+        while exit_epoch >= epoch {
+            exit_epoch -= 1;
+        }
+        assert!(activation_epoch < exit_epoch && exit_epoch < epoch);
+
+        for validator in validators.iter_mut() {
+            validator.exit_epoch = exit_epoch;
+        }
+    }
+
+    #[test]
+    fn can_get_some_active_validator_indices() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        const COUNT_PARTITIONS: usize = 3;
+        const COUNT_VALIDATORS: usize = 3 * COUNT_PARTITIONS;
+        let some_epoch: Epoch = Epoch::random_for_test(&mut rng);
+
+        let mut validators = (0..COUNT_VALIDATORS)
+            .into_iter()
+            .map(|_| {
+                let mut validator = Validator::default();
+
+                let activation_offset = Epoch::random_for_test(&mut rng);
+                let exit_offset = Epoch::random_for_test(&mut rng);
+
+                validator.activation_epoch = some_epoch - activation_offset;
+                validator.exit_epoch = some_epoch + exit_offset;
+
+                validator
+            })
+            .collect::<Vec<_>>();
+
+        // we partition the set into partitions based on lifecycle:
+        for (i, chunk) in validators.chunks_exact_mut(COUNT_PARTITIONS).enumerate() {
+            match i {
+                0 => {
+                    // 1. not activated (Default::default())
+                    set_validators_to_default_entry_exit(chunk);
+                }
+                1 => {
+                    // 2. activated, but not exited
+                    set_validators_to_activated(chunk, some_epoch);
+                    // test boundary condition by ensuring that at least one validator in the list just activated
+                    if let Some(validator) = chunk.get_mut(0) {
+                        validator.activation_epoch = some_epoch;
+                    }
+                }
+                2 => {
+                    // 3. exited
+                    let activation_epoch = set_validators_to_activated(chunk, some_epoch);
+                    set_validators_to_exited(chunk, some_epoch, activation_epoch);
+                    // test boundary condition by ensuring that at least one validator in the list just exited
+                    if let Some(validator) = chunk.get_mut(0) {
+                        validator.exit_epoch = some_epoch;
+                    }
+                }
+                _ => unreachable!(
+                    "constants local to this test not in sync with generation of test case"
+                ),
+            }
+        }
+
+        let indices = get_active_validator_indices(&validators, some_epoch);
+        assert_eq!(indices, vec![3, 4, 5]);
+    }
+}

eth2/types/src/validator_registry_delta_block.rs

@@ -0,0 +1,113 @@
+use crate::{test_utils::TestRandom, Hash256, Slot};
+use bls::PublicKey;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+
+// The information gathered from the PoW chain validator registration function.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct ValidatorRegistryDeltaBlock {
+    pub latest_registry_delta_root: Hash256,
+    pub validator_index: u32,
+    pub pubkey: PublicKey,
+    pub slot: Slot,
+    pub flag: u64,
+}
+
+impl Default for ValidatorRegistryDeltaBlock {
+    /// Yields a "default" `Validator`. Primarily used for testing.
+    fn default() -> Self {
+        Self {
+            latest_registry_delta_root: Hash256::zero(),
+            validator_index: std::u32::MAX,
+            pubkey: PublicKey::default(),
+            slot: Slot::from(std::u64::MAX),
+            flag: std::u64::MAX,
+        }
+    }
+}
+
+impl Encodable for ValidatorRegistryDeltaBlock {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append(&self.latest_registry_delta_root);
+        s.append(&self.validator_index);
+        s.append(&self.pubkey);
+        s.append(&self.slot);
+        s.append(&self.flag);
+    }
+}
+
+impl Decodable for ValidatorRegistryDeltaBlock {
+    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
+        let (latest_registry_delta_root, i) = <_>::ssz_decode(bytes, i)?;
+        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
+        let (pubkey, i) = <_>::ssz_decode(bytes, i)?;
+        let (slot, i) = <_>::ssz_decode(bytes, i)?;
+        let (flag, i) = <_>::ssz_decode(bytes, i)?;
+
+        Ok((
+            Self {
+                latest_registry_delta_root,
+                validator_index,
+                pubkey,
+                slot,
+                flag,
+            },
+            i,
+        ))
+    }
+}
+
+impl TreeHash for ValidatorRegistryDeltaBlock {
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result: Vec<u8> = vec![];
+        result.append(&mut self.latest_registry_delta_root.hash_tree_root());
+        result.append(&mut self.validator_index.hash_tree_root());
+        result.append(&mut self.pubkey.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root());
+        result.append(&mut self.flag.hash_tree_root());
+        hash(&result)
+    }
+}
+
+impl<T: RngCore> TestRandom<T> for ValidatorRegistryDeltaBlock {
+    fn random_for_test(rng: &mut T) -> Self {
+        Self {
+            latest_registry_delta_root: <_>::random_for_test(rng),
+            validator_index: <_>::random_for_test(rng),
+            pubkey: <_>::random_for_test(rng),
+            slot: <_>::random_for_test(rng),
+            flag: <_>::random_for_test(rng),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::ssz_encode;
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+}