Strip out old code

All of these files have been moved to either:

- https://github.com/sigp/lighthouse-beacon
- https://github.com/sigp/lighthouse-validator
- https://github.com/sigp/lighthouse-common

For rationale, see: https://github.com/sigp/lighthouse/issues/197

eth2/attester/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "attester"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-slot_clock = { path = "../../eth2/utils/slot_clock" }
-ssz = { path = "../../eth2/utils/ssz" }
-types = { path = "../../eth2/types" }

eth2/attester/src/lib.rs

@@ -1,250 +0,0 @@
-pub mod test_utils;
-mod traits;
-
-use slot_clock::SlotClock;
-use std::sync::Arc;
-use types::{AttestationData, FreeAttestation, Signature, Slot};
-
-pub use self::traits::{
-    BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
-};
-
-const PHASE_0_CUSTODY_BIT: bool = false;
-
-#[derive(Debug, PartialEq)]
-pub enum PollOutcome {
-    AttestationProduced(Slot),
-    AttestationNotRequired(Slot),
-    SlashableAttestationNotProduced(Slot),
-    BeaconNodeUnableToProduceAttestation(Slot),
-    ProducerDutiesUnknown(Slot),
-    SlotAlreadyProcessed(Slot),
-    SignerRejection(Slot),
-    ValidatorIsUnknown(Slot),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    SlotClockError,
-    SlotUnknowable,
-    EpochMapPoisoned,
-    SlotClockPoisoned,
-    EpochLengthIsZero,
-    BeaconNodeError(BeaconNodeError),
-}
-
-/// A polling state machine which performs block production duties, based upon some epoch duties
-/// (`EpochDutiesMap`) and a concept of time (`SlotClock`).
-///
-/// Ensures that messages are not slashable.
-///
-/// Relies upon an external service to keep the `EpochDutiesMap` updated.
-pub struct Attester<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> {
-    pub last_processed_slot: Option<Slot>,
-    duties: Arc<V>,
-    slot_clock: Arc<T>,
-    beacon_node: Arc<U>,
-    signer: Arc<W>,
-}
-
-impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> Attester<T, U, V, W> {
-    /// Returns a new instance where `last_processed_slot == 0`.
-    pub fn new(duties: Arc<V>, slot_clock: Arc<T>, beacon_node: Arc<U>, signer: Arc<W>) -> Self {
-        Self {
-            last_processed_slot: None,
-            duties,
-            slot_clock,
-            beacon_node,
-            signer,
-        }
-    }
-}
-
-impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> Attester<T, U, V, W> {
-    /// Poll the `BeaconNode` and produce an attestation if required.
-    pub fn poll(&mut self) -> Result<PollOutcome, Error> {
-        let slot = self
-            .slot_clock
-            .present_slot()
-            .map_err(|_| Error::SlotClockError)?
-            .ok_or(Error::SlotUnknowable)?;
-
-        if !self.is_processed_slot(slot) {
-            self.last_processed_slot = Some(slot);
-
-            let shard = match self.duties.attestation_shard(slot) {
-                Ok(Some(result)) => result,
-                Ok(None) => return Ok(PollOutcome::AttestationNotRequired(slot)),
-                Err(DutiesReaderError::UnknownEpoch) => {
-                    return Ok(PollOutcome::ProducerDutiesUnknown(slot));
-                }
-                Err(DutiesReaderError::UnknownValidator) => {
-                    return Ok(PollOutcome::ValidatorIsUnknown(slot));
-                }
-                Err(DutiesReaderError::EpochLengthIsZero) => return Err(Error::EpochLengthIsZero),
-                Err(DutiesReaderError::Poisoned) => return Err(Error::EpochMapPoisoned),
-            };
-
-            self.produce_attestation(slot, shard)
-        } else {
-            Ok(PollOutcome::SlotAlreadyProcessed(slot))
-        }
-    }
-
-    fn produce_attestation(&mut self, slot: Slot, shard: u64) -> Result<PollOutcome, Error> {
-        let attestation_data = match self.beacon_node.produce_attestation_data(slot, shard)? {
-            Some(attestation_data) => attestation_data,
-            None => return Ok(PollOutcome::BeaconNodeUnableToProduceAttestation(slot)),
-        };
-
-        if !self.safe_to_produce(&attestation_data) {
-            return Ok(PollOutcome::SlashableAttestationNotProduced(slot));
-        }
-
-        let signature = match self.sign_attestation_data(&attestation_data) {
-            Some(signature) => signature,
-            None => return Ok(PollOutcome::SignerRejection(slot)),
-        };
-
-        let validator_index = match self.duties.validator_index() {
-            Some(validator_index) => validator_index,
-            None => return Ok(PollOutcome::ValidatorIsUnknown(slot)),
-        };
-
-        let free_attestation = FreeAttestation {
-            data: attestation_data,
-            signature,
-            validator_index,
-        };
-
-        self.beacon_node
-            .publish_attestation_data(free_attestation)?;
-        Ok(PollOutcome::AttestationProduced(slot))
-    }
-
-    fn is_processed_slot(&self, slot: Slot) -> bool {
-        match self.last_processed_slot {
-            Some(processed_slot) if slot <= processed_slot => true,
-            _ => false,
-        }
-    }
-
-    /// Consumes a block, returning that block signed by the validators private key.
-    ///
-    /// Important: this function will not check to ensure the block is not slashable. This must be
-    /// done upstream.
-    fn sign_attestation_data(&mut self, attestation_data: &AttestationData) -> Option<Signature> {
-        self.store_produce(attestation_data);
-
-        self.signer
-            .sign_attestation_message(&attestation_data.signable_message(PHASE_0_CUSTODY_BIT)[..])
-    }
-
-    /// Returns `true` if signing some attestation_data is safe (non-slashable).
-    ///
-    /// !!! UNSAFE !!!
-    ///
-    /// Important: this function is presently stubbed-out. It provides ZERO SAFETY.
-    fn safe_to_produce(&self, _attestation_data: &AttestationData) -> bool {
-        // TODO: ensure the producer doesn't produce slashable blocks.
-        // https://github.com/sigp/lighthouse/issues/160
-        true
-    }
-
-    /// Record that a block was produced so that slashable votes may not be made in the future.
-    ///
-    /// !!! UNSAFE !!!
-    ///
-    /// Important: this function is presently stubbed-out. It provides ZERO SAFETY.
-    fn store_produce(&mut self, _block: &AttestationData) {
-        // TODO: record this block production to prevent future slashings.
-        // https://github.com/sigp/lighthouse/issues/160
-    }
-}
-
-impl From<BeaconNodeError> for Error {
-    fn from(e: BeaconNodeError) -> Error {
-        Error::BeaconNodeError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::test_utils::{EpochMap, LocalSigner, SimulatedBeaconNode};
-    use super::*;
-    use slot_clock::TestingSlotClock;
-    use types::{
-        test_utils::{SeedableRng, TestRandom, XorShiftRng},
-        ChainSpec, Keypair,
-    };
-
-    // TODO: implement more thorough testing.
-    // https://github.com/sigp/lighthouse/issues/160
-    //
-    // These tests should serve as a good example for future tests.
-
-    #[test]
-    pub fn polling() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-
-        let spec = Arc::new(ChainSpec::foundation());
-        let slot_clock = Arc::new(TestingSlotClock::new(0));
-        let beacon_node = Arc::new(SimulatedBeaconNode::default());
-        let signer = Arc::new(LocalSigner::new(Keypair::random()));
-
-        let mut duties = EpochMap::new(spec.epoch_length);
-        let attest_slot = Slot::new(100);
-        let attest_epoch = attest_slot / spec.epoch_length;
-        let attest_shard = 12;
-        duties.insert_attestation_shard(attest_slot, attest_shard);
-        duties.set_validator_index(Some(2));
-        let duties = Arc::new(duties);
-
-        let mut attester = Attester::new(
-            duties.clone(),
-            slot_clock.clone(),
-            beacon_node.clone(),
-            signer.clone(),
-        );
-
-        // Configure responses from the BeaconNode.
-        beacon_node.set_next_produce_result(Ok(Some(AttestationData::random_for_test(&mut rng))));
-        beacon_node.set_next_publish_result(Ok(PublishOutcome::ValidAttestation));
-
-        // One slot before attestation slot...
-        slot_clock.set_slot(attest_slot.as_u64() - 1);
-        assert_eq!(
-            attester.poll(),
-            Ok(PollOutcome::AttestationNotRequired(attest_slot - 1))
-        );
-
-        // On the attest slot...
-        slot_clock.set_slot(attest_slot.as_u64());
-        assert_eq!(
-            attester.poll(),
-            Ok(PollOutcome::AttestationProduced(attest_slot))
-        );
-
-        // Trying the same attest slot again...
-        slot_clock.set_slot(attest_slot.as_u64());
-        assert_eq!(
-            attester.poll(),
-            Ok(PollOutcome::SlotAlreadyProcessed(attest_slot))
-        );
-
-        // One slot after the attest slot...
-        slot_clock.set_slot(attest_slot.as_u64() + 1);
-        assert_eq!(
-            attester.poll(),
-            Ok(PollOutcome::AttestationNotRequired(attest_slot + 1))
-        );
-
-        // In an epoch without known duties...
-        let slot = (attest_epoch + 1) * spec.epoch_length;
-        slot_clock.set_slot(slot.into());
-        assert_eq!(
-            attester.poll(),
-            Ok(PollOutcome::ProducerDutiesUnknown(slot))
-        );
-    }
-}

eth2/attester/src/test_utils/epoch_map.rs

@@ -1,44 +0,0 @@
-use crate::{DutiesReader, DutiesReaderError};
-use std::collections::HashMap;
-use types::{Epoch, Slot};
-
-pub struct EpochMap {
-    epoch_length: u64,
-    validator_index: Option<u64>,
-    map: HashMap<Epoch, (Slot, u64)>,
-}
-
-impl EpochMap {
-    pub fn new(epoch_length: u64) -> Self {
-        Self {
-            epoch_length,
-            validator_index: None,
-            map: HashMap::new(),
-        }
-    }
-
-    pub fn insert_attestation_shard(&mut self, slot: Slot, shard: u64) {
-        let epoch = slot.epoch(self.epoch_length);
-        self.map.insert(epoch, (slot, shard));
-    }
-
-    pub fn set_validator_index(&mut self, index: Option<u64>) {
-        self.validator_index = index;
-    }
-}
-
-impl DutiesReader for EpochMap {
-    fn attestation_shard(&self, slot: Slot) -> Result<Option<u64>, DutiesReaderError> {
-        let epoch = slot.epoch(self.epoch_length);
-
-        match self.map.get(&epoch) {
-            Some((attest_slot, attest_shard)) if *attest_slot == slot => Ok(Some(*attest_shard)),
-            Some((attest_slot, _attest_shard)) if *attest_slot != slot => Ok(None),
-            _ => Err(DutiesReaderError::UnknownEpoch),
-        }
-    }
-
-    fn validator_index(&self) -> Option<u64> {
-        self.validator_index
-    }
-}

eth2/attester/src/test_utils/local_signer.rs

@@ -1,31 +0,0 @@
-use crate::traits::Signer;
-use std::sync::RwLock;
-use types::{Keypair, Signature};
-
-/// A test-only struct used to simulate a Beacon Node.
-pub struct LocalSigner {
-    keypair: Keypair,
-    should_sign: RwLock<bool>,
-}
-
-impl LocalSigner {
-    /// Produce a new LocalSigner with signing enabled by default.
-    pub fn new(keypair: Keypair) -> Self {
-        Self {
-            keypair,
-            should_sign: RwLock::new(true),
-        }
-    }
-
-    /// If set to `false`, the service will refuse to sign all messages. Otherwise, all messages
-    /// will be signed.
-    pub fn enable_signing(&self, enabled: bool) {
-        *self.should_sign.write().unwrap() = enabled;
-    }
-}
-
-impl Signer for LocalSigner {
-    fn sign_attestation_message(&self, message: &[u8]) -> Option<Signature> {
-        Some(Signature::new(message, &self.keypair.sk))
-    }
-}

eth2/attester/src/test_utils/mod.rs

@@ -1,7 +0,0 @@
-mod epoch_map;
-mod local_signer;
-mod simulated_beacon_node;
-
-pub use self::epoch_map::EpochMap;
-pub use self::local_signer::LocalSigner;
-pub use self::simulated_beacon_node::SimulatedBeaconNode;

eth2/attester/src/test_utils/simulated_beacon_node.rs

@@ -1,44 +0,0 @@
-use crate::traits::{BeaconNode, BeaconNodeError, PublishOutcome};
-use std::sync::RwLock;
-use types::{AttestationData, FreeAttestation, Slot};
-
-type ProduceResult = Result<Option<AttestationData>, BeaconNodeError>;
-type PublishResult = Result<PublishOutcome, BeaconNodeError>;
-
-/// A test-only struct used to simulate a Beacon Node.
-#[derive(Default)]
-pub struct SimulatedBeaconNode {
-    pub produce_input: RwLock<Option<(Slot, u64)>>,
-    pub produce_result: RwLock<Option<ProduceResult>>,
-
-    pub publish_input: RwLock<Option<FreeAttestation>>,
-    pub publish_result: RwLock<Option<PublishResult>>,
-}
-
-impl SimulatedBeaconNode {
-    pub fn set_next_produce_result(&self, result: ProduceResult) {
-        *self.produce_result.write().unwrap() = Some(result);
-    }
-
-    pub fn set_next_publish_result(&self, result: PublishResult) {
-        *self.publish_result.write().unwrap() = Some(result);
-    }
-}
-
-impl BeaconNode for SimulatedBeaconNode {
-    fn produce_attestation_data(&self, slot: Slot, shard: u64) -> ProduceResult {
-        *self.produce_input.write().unwrap() = Some((slot, shard));
-        match *self.produce_result.read().unwrap() {
-            Some(ref r) => r.clone(),
-            None => panic!("TestBeaconNode: produce_result == None"),
-        }
-    }
-
-    fn publish_attestation_data(&self, free_attestation: FreeAttestation) -> PublishResult {
-        *self.publish_input.write().unwrap() = Some(free_attestation.clone());
-        match *self.publish_result.read().unwrap() {
-            Some(ref r) => r.clone(),
-            None => panic!("TestBeaconNode: publish_result == None"),
-        }
-    }
-}

eth2/attester/src/traits.rs

@@ -1,49 +0,0 @@
-use types::{AttestationData, FreeAttestation, Signature, Slot};
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum BeaconNodeError {
-    RemoteFailure(String),
-    DecodeFailure,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum PublishOutcome {
-    ValidAttestation,
-    InvalidAttestation(String),
-}
-
-/// Defines the methods required to produce and publish blocks on a Beacon Node.
-pub trait BeaconNode: Send + Sync {
-    fn produce_attestation_data(
-        &self,
-        slot: Slot,
-        shard: u64,
-    ) -> Result<Option<AttestationData>, BeaconNodeError>;
-
-    fn publish_attestation_data(
-        &self,
-        free_attestation: FreeAttestation,
-    ) -> Result<PublishOutcome, BeaconNodeError>;
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum DutiesReaderError {
-    UnknownValidator,
-    UnknownEpoch,
-    EpochLengthIsZero,
-    Poisoned,
-}
-
-/// Informs a validator of their duties (e.g., block production).
-pub trait DutiesReader: Send + Sync {
-    /// Returns `Some(shard)` if this slot is an attestation slot. Otherwise, returns `None.`
-    fn attestation_shard(&self, slot: Slot) -> Result<Option<u64>, DutiesReaderError>;
-
-    /// Returns `Some(shard)` if this slot is an attestation slot. Otherwise, returns `None.`
-    fn validator_index(&self) -> Option<u64>;
-}
-
-/// Signs message using an internally-maintained private key.
-pub trait Signer {
-    fn sign_attestation_message(&self, message: &[u8]) -> Option<Signature>;
-}

eth2/block_producer/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "block_producer"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-slot_clock = { path = "../../eth2/utils/slot_clock" }
-ssz = { path = "../../eth2/utils/ssz" }
-types = { path = "../../eth2/types" }

eth2/block_producer/src/lib.rs

@@ -1,287 +0,0 @@
-pub mod test_utils;
-mod traits;
-
-use slot_clock::SlotClock;
-use ssz::ssz_encode;
-use std::sync::Arc;
-use types::{BeaconBlock, ChainSpec, Slot};
-
-pub use self::traits::{
-    BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
-};
-
-#[derive(Debug, PartialEq)]
-pub enum PollOutcome {
-    /// A new block was produced.
-    BlockProduced(Slot),
-    /// A block was not produced as it would have been slashable.
-    SlashableBlockNotProduced(Slot),
-    /// The validator duties did not require a block to be produced.
-    BlockProductionNotRequired(Slot),
-    /// The duties for the present epoch were not found.
-    ProducerDutiesUnknown(Slot),
-    /// The slot has already been processed, execution was skipped.
-    SlotAlreadyProcessed(Slot),
-    /// The Beacon Node was unable to produce a block at that slot.
-    BeaconNodeUnableToProduceBlock(Slot),
-    /// The signer failed to sign the message.
-    SignerRejection(Slot),
-    /// The public key for this validator is not an active validator.
-    ValidatorIsUnknown(Slot),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    SlotClockError,
-    SlotUnknowable,
-    EpochMapPoisoned,
-    SlotClockPoisoned,
-    EpochLengthIsZero,
-    BeaconNodeError(BeaconNodeError),
-}
-
-/// A polling state machine which performs block production duties, based upon some epoch duties
-/// (`EpochDutiesMap`) and a concept of time (`SlotClock`).
-///
-/// Ensures that messages are not slashable.
-///
-/// Relies upon an external service to keep the `EpochDutiesMap` updated.
-pub struct BlockProducer<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> {
-    pub last_processed_slot: Option<Slot>,
-    spec: Arc<ChainSpec>,
-    epoch_map: Arc<V>,
-    slot_clock: Arc<T>,
-    beacon_node: Arc<U>,
-    signer: Arc<W>,
-}
-
-impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U, V, W> {
-    /// Returns a new instance where `last_processed_slot == 0`.
-    pub fn new(
-        spec: Arc<ChainSpec>,
-        epoch_map: Arc<V>,
-        slot_clock: Arc<T>,
-        beacon_node: Arc<U>,
-        signer: Arc<W>,
-    ) -> Self {
-        Self {
-            last_processed_slot: None,
-            spec,
-            epoch_map,
-            slot_clock,
-            beacon_node,
-            signer,
-        }
-    }
-}
-
-impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U, V, W> {
-    /// "Poll" to see if the validator is required to take any action.
-    ///
-    /// The slot clock will be read and any new actions undertaken.
-    pub fn poll(&mut self) -> Result<PollOutcome, Error> {
-        let slot = self
-            .slot_clock
-            .present_slot()
-            .map_err(|_| Error::SlotClockError)?
-            .ok_or(Error::SlotUnknowable)?;
-
-        // If this is a new slot.
-        if !self.is_processed_slot(slot) {
-            let is_block_production_slot = match self.epoch_map.is_block_production_slot(slot) {
-                Ok(result) => result,
-                Err(DutiesReaderError::UnknownEpoch) => {
-                    return Ok(PollOutcome::ProducerDutiesUnknown(slot));
-                }
-                Err(DutiesReaderError::UnknownValidator) => {
-                    return Ok(PollOutcome::ValidatorIsUnknown(slot));
-                }
-                Err(DutiesReaderError::EpochLengthIsZero) => return Err(Error::EpochLengthIsZero),
-                Err(DutiesReaderError::Poisoned) => return Err(Error::EpochMapPoisoned),
-            };
-
-            if is_block_production_slot {
-                self.last_processed_slot = Some(slot);
-
-                self.produce_block(slot)
-            } else {
-                Ok(PollOutcome::BlockProductionNotRequired(slot))
-            }
-        } else {
-            Ok(PollOutcome::SlotAlreadyProcessed(slot))
-        }
-    }
-
-    fn is_processed_slot(&self, slot: Slot) -> bool {
-        match self.last_processed_slot {
-            Some(processed_slot) if processed_slot >= slot => true,
-            _ => false,
-        }
-    }
-
-    /// Produce a block at some slot.
-    ///
-    /// Assumes that a block is required at this slot (does not check the duties).
-    ///
-    /// Ensures the message is not slashable.
-    ///
-    /// !!! UNSAFE !!!
-    ///
-    /// The slash-protection code is not yet implemented. There is zero protection against
-    /// slashing.
-    fn produce_block(&mut self, slot: Slot) -> Result<PollOutcome, Error> {
-        let randao_reveal = {
-            // TODO: add domain, etc to this message. Also ensure result matches `into_to_bytes32`.
-            let message = ssz_encode(&slot.epoch(self.spec.epoch_length));
-
-            match self.signer.sign_randao_reveal(&message) {
-                None => return Ok(PollOutcome::SignerRejection(slot)),
-                Some(signature) => signature,
-            }
-        };
-
-        if let Some(block) = self
-            .beacon_node
-            .produce_beacon_block(slot, &randao_reveal)?
-        {
-            if self.safe_to_produce(&block) {
-                if let Some(block) = self.sign_block(block) {
-                    self.beacon_node.publish_beacon_block(block)?;
-                    Ok(PollOutcome::BlockProduced(slot))
-                } else {
-                    Ok(PollOutcome::SignerRejection(slot))
-                }
-            } else {
-                Ok(PollOutcome::SlashableBlockNotProduced(slot))
-            }
-        } else {
-            Ok(PollOutcome::BeaconNodeUnableToProduceBlock(slot))
-        }
-    }
-
-    /// Consumes a block, returning that block signed by the validators private key.
-    ///
-    /// Important: this function will not check to ensure the block is not slashable. This must be
-    /// done upstream.
-    fn sign_block(&mut self, mut block: BeaconBlock) -> Option<BeaconBlock> {
-        self.store_produce(&block);
-
-        match self
-            .signer
-            .sign_block_proposal(&block.proposal_root(&self.spec)[..])
-        {
-            None => None,
-            Some(signature) => {
-                block.signature = signature;
-                Some(block)
-            }
-        }
-    }
-
-    /// Returns `true` if signing a block is safe (non-slashable).
-    ///
-    /// !!! UNSAFE !!!
-    ///
-    /// Important: this function is presently stubbed-out. It provides ZERO SAFETY.
-    fn safe_to_produce(&self, _block: &BeaconBlock) -> bool {
-        // TODO: ensure the producer doesn't produce slashable blocks.
-        // https://github.com/sigp/lighthouse/issues/160
-        true
-    }
-
-    /// Record that a block was produced so that slashable votes may not be made in the future.
-    ///
-    /// !!! UNSAFE !!!
-    ///
-    /// Important: this function is presently stubbed-out. It provides ZERO SAFETY.
-    fn store_produce(&mut self, _block: &BeaconBlock) {
-        // TODO: record this block production to prevent future slashings.
-        // https://github.com/sigp/lighthouse/issues/160
-    }
-}
-
-impl From<BeaconNodeError> for Error {
-    fn from(e: BeaconNodeError) -> Error {
-        Error::BeaconNodeError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::test_utils::{EpochMap, LocalSigner, SimulatedBeaconNode};
-    use super::*;
-    use slot_clock::TestingSlotClock;
-    use types::{
-        test_utils::{SeedableRng, TestRandom, XorShiftRng},
-        Keypair,
-    };
-
-    // TODO: implement more thorough testing.
-    // https://github.com/sigp/lighthouse/issues/160
-    //
-    // These tests should serve as a good example for future tests.
-
-    #[test]
-    pub fn polling() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-
-        let spec = Arc::new(ChainSpec::foundation());
-        let slot_clock = Arc::new(TestingSlotClock::new(0));
-        let beacon_node = Arc::new(SimulatedBeaconNode::default());
-        let signer = Arc::new(LocalSigner::new(Keypair::random()));
-
-        let mut epoch_map = EpochMap::new(spec.epoch_length);
-        let produce_slot = Slot::new(100);
-        let produce_epoch = produce_slot.epoch(spec.epoch_length);
-        epoch_map.map.insert(produce_epoch, produce_slot);
-        let epoch_map = Arc::new(epoch_map);
-
-        let mut block_producer = BlockProducer::new(
-            spec.clone(),
-            epoch_map.clone(),
-            slot_clock.clone(),
-            beacon_node.clone(),
-            signer.clone(),
-        );
-
-        // Configure responses from the BeaconNode.
-        beacon_node.set_next_produce_result(Ok(Some(BeaconBlock::random_for_test(&mut rng))));
-        beacon_node.set_next_publish_result(Ok(PublishOutcome::ValidBlock));
-
-        // One slot before production slot...
-        slot_clock.set_slot(produce_slot.as_u64() - 1);
-        assert_eq!(
-            block_producer.poll(),
-            Ok(PollOutcome::BlockProductionNotRequired(produce_slot - 1))
-        );
-
-        // On the produce slot...
-        slot_clock.set_slot(produce_slot.as_u64());
-        assert_eq!(
-            block_producer.poll(),
-            Ok(PollOutcome::BlockProduced(produce_slot.into()))
-        );
-
-        // Trying the same produce slot again...
-        slot_clock.set_slot(produce_slot.as_u64());
-        assert_eq!(
-            block_producer.poll(),
-            Ok(PollOutcome::SlotAlreadyProcessed(produce_slot))
-        );
-
-        // One slot after the produce slot...
-        slot_clock.set_slot(produce_slot.as_u64() + 1);
-        assert_eq!(
-            block_producer.poll(),
-            Ok(PollOutcome::BlockProductionNotRequired(produce_slot + 1))
-        );
-
-        // In an epoch without known duties...
-        let slot = (produce_epoch.as_u64() + 1) * spec.epoch_length;
-        slot_clock.set_slot(slot);
-        assert_eq!(
-            block_producer.poll(),
-            Ok(PollOutcome::ProducerDutiesUnknown(Slot::new(slot)))
-        );
-    }
-}

eth2/block_producer/src/test_utils/epoch_map.rs

@@ -1,28 +0,0 @@
-use crate::{DutiesReader, DutiesReaderError};
-use std::collections::HashMap;
-use types::{Epoch, Slot};
-
-pub struct EpochMap {
-    epoch_length: u64,
-    pub map: HashMap<Epoch, Slot>,
-}
-
-impl EpochMap {
-    pub fn new(epoch_length: u64) -> Self {
-        Self {
-            epoch_length,
-            map: HashMap::new(),
-        }
-    }
-}
-
-impl DutiesReader for EpochMap {
-    fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError> {
-        let epoch = slot.epoch(self.epoch_length);
-        match self.map.get(&epoch) {
-            Some(s) if *s == slot => Ok(true),
-            Some(s) if *s != slot => Ok(false),
-            _ => Err(DutiesReaderError::UnknownEpoch),
-        }
-    }
-}

eth2/block_producer/src/test_utils/local_signer.rs

@@ -1,35 +0,0 @@
-use crate::traits::Signer;
-use std::sync::RwLock;
-use types::{Keypair, Signature};
-
-/// A test-only struct used to simulate a Beacon Node.
-pub struct LocalSigner {
-    keypair: Keypair,
-    should_sign: RwLock<bool>,
-}
-
-impl LocalSigner {
-    /// Produce a new LocalSigner with signing enabled by default.
-    pub fn new(keypair: Keypair) -> Self {
-        Self {
-            keypair,
-            should_sign: RwLock::new(true),
-        }
-    }
-
-    /// If set to `false`, the service will refuse to sign all messages. Otherwise, all messages
-    /// will be signed.
-    pub fn enable_signing(&self, enabled: bool) {
-        *self.should_sign.write().unwrap() = enabled;
-    }
-}
-
-impl Signer for LocalSigner {
-    fn sign_block_proposal(&self, message: &[u8]) -> Option<Signature> {
-        Some(Signature::new(message, &self.keypair.sk))
-    }
-
-    fn sign_randao_reveal(&self, message: &[u8]) -> Option<Signature> {
-        Some(Signature::new(message, &self.keypair.sk))
-    }
-}

eth2/block_producer/src/test_utils/mod.rs

@@ -1,7 +0,0 @@
-mod epoch_map;
-mod local_signer;
-mod simulated_beacon_node;
-
-pub use self::epoch_map::EpochMap;
-pub use self::local_signer::LocalSigner;
-pub use self::simulated_beacon_node::SimulatedBeaconNode;

eth2/block_producer/src/test_utils/simulated_beacon_node.rs

@@ -1,48 +0,0 @@
-use crate::traits::{BeaconNode, BeaconNodeError, PublishOutcome};
-use std::sync::RwLock;
-use types::{BeaconBlock, Signature, Slot};
-
-type ProduceResult = Result<Option<BeaconBlock>, BeaconNodeError>;
-type PublishResult = Result<PublishOutcome, BeaconNodeError>;
-
-/// A test-only struct used to simulate a Beacon Node.
-#[derive(Default)]
-pub struct SimulatedBeaconNode {
-    pub produce_input: RwLock<Option<(Slot, Signature)>>,
-    pub produce_result: RwLock<Option<ProduceResult>>,
-
-    pub publish_input: RwLock<Option<BeaconBlock>>,
-    pub publish_result: RwLock<Option<PublishResult>>,
-}
-
-impl SimulatedBeaconNode {
-    /// Set the result to be returned when `produce_beacon_block` is called.
-    pub fn set_next_produce_result(&self, result: ProduceResult) {
-        *self.produce_result.write().unwrap() = Some(result);
-    }
-
-    /// Set the result to be returned when `publish_beacon_block` is called.
-    pub fn set_next_publish_result(&self, result: PublishResult) {
-        *self.publish_result.write().unwrap() = Some(result);
-    }
-}
-
-impl BeaconNode for SimulatedBeaconNode {
-    /// Returns the value specified by the `set_next_produce_result`.
-    fn produce_beacon_block(&self, slot: Slot, randao_reveal: &Signature) -> ProduceResult {
-        *self.produce_input.write().unwrap() = Some((slot, randao_reveal.clone()));
-        match *self.produce_result.read().unwrap() {
-            Some(ref r) => r.clone(),
-            None => panic!("SimulatedBeaconNode: produce_result == None"),
-        }
-    }
-
-    /// Returns the value specified by the `set_next_publish_result`.
-    fn publish_beacon_block(&self, block: BeaconBlock) -> PublishResult {
-        *self.publish_input.write().unwrap() = Some(block);
-        match *self.publish_result.read().unwrap() {
-            Some(ref r) => r.clone(),
-            None => panic!("SimulatedBeaconNode: publish_result == None"),
-        }
-    }
-}

eth2/block_producer/src/traits.rs

@@ -1,49 +0,0 @@
-use types::{BeaconBlock, Signature, Slot};
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum BeaconNodeError {
-    RemoteFailure(String),
-    DecodeFailure,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum PublishOutcome {
-    ValidBlock,
-    InvalidBlock(String),
-}
-
-/// Defines the methods required to produce and publish blocks on a Beacon Node.
-pub trait BeaconNode: Send + Sync {
-    /// Request that the node produces a block.
-    ///
-    /// Returns Ok(None) if the Beacon Node is unable to produce at the given slot.
-    fn produce_beacon_block(
-        &self,
-        slot: Slot,
-        randao_reveal: &Signature,
-    ) -> Result<Option<BeaconBlock>, BeaconNodeError>;
-
-    /// Request that the node publishes a block.
-    ///
-    /// Returns `true` if the publish was sucessful.
-    fn publish_beacon_block(&self, block: BeaconBlock) -> Result<PublishOutcome, BeaconNodeError>;
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum DutiesReaderError {
-    UnknownValidator,
-    UnknownEpoch,
-    EpochLengthIsZero,
-    Poisoned,
-}
-
-/// Informs a validator of their duties (e.g., block production).
-pub trait DutiesReader: Send + Sync {
-    fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError>;
-}
-
-/// Signs message using an internally-maintained private key.
-pub trait Signer {
-    fn sign_block_proposal(&self, message: &[u8]) -> Option<Signature>;
-    fn sign_randao_reveal(&self, message: &[u8]) -> Option<Signature>;
-}

eth2/naive_fork_choice/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "naive_fork_choice"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-db = { path = "../../beacon_node/db" }
-ssz = { path = "../utils/ssz" }
-types = { path = "../types" }

eth2/naive_fork_choice/src/lib.rs

@@ -1,97 +0,0 @@
-extern crate db;
-extern crate ssz;
-extern crate types;
-
-use db::stores::BeaconBlockStore;
-use db::{ClientDB, DBError};
-use ssz::{Decodable, DecodeError};
-use std::sync::Arc;
-use types::{BeaconBlock, Hash256, Slot};
-
-pub enum ForkChoiceError {
-    BadSszInDatabase,
-    MissingBlock,
-    DBError(String),
-}
-
-pub fn naive_fork_choice<T>(
-    head_block_hashes: &[Hash256],
-    block_store: &Arc<BeaconBlockStore<T>>,
-) -> Result<Option<usize>, ForkChoiceError>
-where
-    T: ClientDB + Sized,
-{
-    let mut head_blocks: Vec<(usize, BeaconBlock)> = vec![];
-
-    /*
-     * Load all the head_block hashes from the DB as SszBeaconBlocks.
-     */
-    for (index, block_hash) in head_block_hashes.iter().enumerate() {
-        let ssz = block_store
-            .get(&block_hash)?
-            .ok_or(ForkChoiceError::MissingBlock)?;
-        let (block, _) = BeaconBlock::ssz_decode(&ssz, 0)?;
-        head_blocks.push((index, block));
-    }
-
-    /*
-     * Loop through all the head blocks and find the highest slot.
-     */
-    let highest_slot: Option<Slot> = None;
-    for (_, block) in &head_blocks {
-        let slot = block.slot;
-
-        match highest_slot {
-            None => Some(slot),
-            Some(winning_slot) => {
-                if slot > winning_slot {
-                    Some(slot)
-                } else {
-                    Some(winning_slot)
-                }
-            }
-        };
-    }
-
-    /*
-     * Loop through all the highest blocks and sort them by highest hash.
-     *
-     * Ultimately, the index of the head_block hash with the highest slot and highest block
-     * hash will be the winner.
-     */
-    match highest_slot {
-        None => Ok(None),
-        Some(highest_slot) => {
-            let mut highest_blocks = vec![];
-            for (index, block) in head_blocks {
-                if block.slot == highest_slot {
-                    highest_blocks.push((index, block))
-                }
-            }
-
-            highest_blocks.sort_by(|a, b| head_block_hashes[a.0].cmp(&head_block_hashes[b.0]));
-            let (index, _) = highest_blocks[0];
-            Ok(Some(index))
-        }
-    }
-}
-
-impl From<DecodeError> for ForkChoiceError {
-    fn from(_: DecodeError) -> Self {
-        ForkChoiceError::BadSszInDatabase
-    }
-}
-
-impl From<DBError> for ForkChoiceError {
-    fn from(e: DBError) -> Self {
-        ForkChoiceError::DBError(e.message)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_naive_fork_choice() {
-        assert_eq!(2 + 2, 4);
-    }
-}

eth2/state_processing/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "state_processing"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-hashing = { path = "../utils/hashing" }
-integer-sqrt = "0.1"
-log = "0.4"
-ssz = { path = "../utils/ssz" }
-types = { path = "../types" }
-rayon = "1.0"

eth2/state_processing/src/block_processable.rs

@@ -1,403 +0,0 @@
-use crate::SlotProcessingError;
-use hashing::hash;
-use log::debug;
-use ssz::{ssz_encode, TreeHash};
-use types::{
-    beacon_state::{AttestationValidationError, CommitteesError},
-    AggregatePublicKey, Attestation, BeaconBlock, BeaconState, ChainSpec, Crosslink, Epoch, Exit,
-    Fork, Hash256, PendingAttestation, PublicKey, Signature,
-};
-
-// TODO: define elsehwere.
-const DOMAIN_PROPOSAL: u64 = 2;
-const DOMAIN_EXIT: u64 = 3;
-const DOMAIN_RANDAO: u64 = 4;
-const PHASE_0_CUSTODY_BIT: bool = false;
-const DOMAIN_ATTESTATION: u64 = 1;
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    DBError(String),
-    StateAlreadyTransitioned,
-    PresentSlotIsNone,
-    UnableToDecodeBlock,
-    MissingParentState(Hash256),
-    InvalidParentState(Hash256),
-    MissingBeaconBlock(Hash256),
-    InvalidBeaconBlock(Hash256),
-    MissingParentBlock(Hash256),
-    NoBlockProducer,
-    StateSlotMismatch,
-    BadBlockSignature,
-    BadRandaoSignature,
-    MaxProposerSlashingsExceeded,
-    BadProposerSlashing,
-    MaxAttestationsExceeded,
-    InvalidAttestation(AttestationValidationError),
-    NoBlockRoot,
-    MaxDepositsExceeded,
-    MaxExitsExceeded,
-    BadExit,
-    BadCustodyReseeds,
-    BadCustodyChallenges,
-    BadCustodyResponses,
-    CommitteesError(CommitteesError),
-    SlotProcessingError(SlotProcessingError),
-}
-
-macro_rules! ensure {
-    ($condition: expr, $result: expr) => {
-        if !$condition {
-            return Err($result);
-        }
-    };
-}
-
-pub trait BlockProcessable {
-    fn per_block_processing(&mut self, block: &BeaconBlock, spec: &ChainSpec) -> Result<(), Error>;
-    fn per_block_processing_without_verifying_block_signature(
-        &mut self,
-        block: &BeaconBlock,
-        spec: &ChainSpec,
-    ) -> Result<(), Error>;
-}
-
-impl BlockProcessable for BeaconState {
-    fn per_block_processing(&mut self, block: &BeaconBlock, spec: &ChainSpec) -> Result<(), Error> {
-        per_block_processing_signature_optional(self, block, true, spec)
-    }
-
-    fn per_block_processing_without_verifying_block_signature(
-        &mut self,
-        block: &BeaconBlock,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        per_block_processing_signature_optional(self, block, false, spec)
-    }
-}
-
-fn per_block_processing_signature_optional(
-    state: &mut BeaconState,
-    block: &BeaconBlock,
-    verify_block_signature: bool,
-    spec: &ChainSpec,
-) -> Result<(), Error> {
-    ensure!(block.slot == state.slot, Error::StateSlotMismatch);
-
-    /*
-     * Proposer Signature
-     */
-    let block_proposer_index = state
-        .get_beacon_proposer_index(block.slot, spec)
-        .map_err(|_| Error::NoBlockProducer)?;
-    let block_proposer = &state.validator_registry[block_proposer_index];
-
-    if verify_block_signature {
-        ensure!(
-            bls_verify(
-                &block_proposer.pubkey,
-                &block.proposal_root(spec)[..],
-                &block.signature,
-                get_domain(&state.fork, state.current_epoch(spec), DOMAIN_PROPOSAL)
-            ),
-            Error::BadBlockSignature
-        );
-    }
-
-    /*
-     * RANDAO
-     */
-    ensure!(
-        bls_verify(
-            &block_proposer.pubkey,
-            &ssz_encode(&state.current_epoch(spec)),
-            &block.randao_reveal,
-            get_domain(&state.fork, state.current_epoch(spec), DOMAIN_RANDAO)
-        ),
-        Error::BadRandaoSignature
-    );
-
-    // TODO: check this is correct.
-    let new_mix = {
-        let mut mix = state.latest_randao_mixes
-            [state.slot.as_usize() % spec.latest_randao_mixes_length]
-            .to_vec();
-        mix.append(&mut ssz_encode(&block.randao_reveal));
-        Hash256::from(&hash(&mix)[..])
-    };
-
-    state.latest_randao_mixes[state.slot.as_usize() % spec.latest_randao_mixes_length] = new_mix;
-
-    /*
-     * Eth1 data
-     */
-    // TODO: Eth1 data processing.
-
-    /*
-     * Proposer slashings
-     */
-    ensure!(
-        block.body.proposer_slashings.len() as u64 <= spec.max_proposer_slashings,
-        Error::MaxProposerSlashingsExceeded
-    );
-    for proposer_slashing in &block.body.proposer_slashings {
-        let proposer = state
-            .validator_registry
-            .get(proposer_slashing.proposer_index as usize)
-            .ok_or(Error::BadProposerSlashing)?;
-        ensure!(
-            proposer_slashing.proposal_data_1.slot == proposer_slashing.proposal_data_2.slot,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer_slashing.proposal_data_1.shard == proposer_slashing.proposal_data_2.shard,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer_slashing.proposal_data_1.block_root
-                != proposer_slashing.proposal_data_2.block_root,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer.penalized_epoch > state.current_epoch(spec),
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            bls_verify(
-                &proposer.pubkey,
-                &proposer_slashing.proposal_data_1.hash_tree_root(),
-                &proposer_slashing.proposal_signature_1,
-                get_domain(
-                    &state.fork,
-                    proposer_slashing
-                        .proposal_data_1
-                        .slot
-                        .epoch(spec.epoch_length),
-                    DOMAIN_PROPOSAL
-                )
-            ),
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            bls_verify(
-                &proposer.pubkey,
-                &proposer_slashing.proposal_data_2.hash_tree_root(),
-                &proposer_slashing.proposal_signature_2,
-                get_domain(
-                    &state.fork,
-                    proposer_slashing
-                        .proposal_data_2
-                        .slot
-                        .epoch(spec.epoch_length),
-                    DOMAIN_PROPOSAL
-                )
-            ),
-            Error::BadProposerSlashing
-        );
-        state.penalize_validator(proposer_slashing.proposer_index as usize, spec)?;
-    }
-
-    /*
-     * Attestations
-     */
-    ensure!(
-        block.body.attestations.len() as u64 <= spec.max_attestations,
-        Error::MaxAttestationsExceeded
-    );
-
-    for attestation in &block.body.attestations {
-        validate_attestation(&state, attestation, spec)?;
-
-        let pending_attestation = PendingAttestation {
-            data: attestation.data.clone(),
-            aggregation_bitfield: attestation.aggregation_bitfield.clone(),
-            custody_bitfield: attestation.custody_bitfield.clone(),
-            inclusion_slot: state.slot,
-        };
-        state.latest_attestations.push(pending_attestation);
-    }
-
-    debug!(
-        "{} attestations verified & processed.",
-        block.body.attestations.len()
-    );
-
-    /*
-     * Deposits
-     */
-    ensure!(
-        block.body.deposits.len() as u64 <= spec.max_deposits,
-        Error::MaxDepositsExceeded
-    );
-
-    // TODO: process deposits.
-
-    /*
-     * Exits
-     */
-    ensure!(
-        block.body.exits.len() as u64 <= spec.max_exits,
-        Error::MaxExitsExceeded
-    );
-
-    for exit in &block.body.exits {
-        let validator = state
-            .validator_registry
-            .get(exit.validator_index as usize)
-            .ok_or(Error::BadExit)?;
-        ensure!(
-            validator.exit_epoch
-                > state.get_entry_exit_effect_epoch(state.current_epoch(spec), spec),
-            Error::BadExit
-        );
-        ensure!(state.current_epoch(spec) >= exit.epoch, Error::BadExit);
-        let exit_message = {
-            let exit_struct = Exit {
-                epoch: exit.epoch,
-                validator_index: exit.validator_index,
-                signature: spec.empty_signature.clone(),
-            };
-            exit_struct.hash_tree_root()
-        };
-        ensure!(
-            bls_verify(
-                &validator.pubkey,
-                &exit_message,
-                &exit.signature,
-                get_domain(&state.fork, exit.epoch, DOMAIN_EXIT)
-            ),
-            Error::BadProposerSlashing
-        );
-        state.initiate_validator_exit(exit.validator_index as usize);
-    }
-
-    debug!("State transition complete.");
-
-    Ok(())
-}
-
-pub fn validate_attestation(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-) -> Result<(), AttestationValidationError> {
-    validate_attestation_signature_optional(state, attestation, spec, true)
-}
-
-pub fn validate_attestation_without_signature(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-) -> Result<(), AttestationValidationError> {
-    validate_attestation_signature_optional(state, attestation, spec, false)
-}
-
-fn validate_attestation_signature_optional(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-    verify_signature: bool,
-) -> Result<(), AttestationValidationError> {
-    ensure!(
-        attestation.data.slot + spec.min_attestation_inclusion_delay <= state.slot,
-        AttestationValidationError::IncludedTooEarly
-    );
-    ensure!(
-        attestation.data.slot + spec.epoch_length >= state.slot,
-        AttestationValidationError::IncludedTooLate
-    );
-    if attestation.data.slot >= state.current_epoch_start_slot(spec) {
-        ensure!(
-            attestation.data.justified_epoch == state.justified_epoch,
-            AttestationValidationError::WrongJustifiedSlot
-        );
-    } else {
-        ensure!(
-            attestation.data.justified_epoch == state.previous_justified_epoch,
-            AttestationValidationError::WrongJustifiedSlot
-        );
-    }
-    ensure!(
-        attestation.data.justified_block_root
-            == *state
-                .get_block_root(
-                    attestation
-                        .data
-                        .justified_epoch
-                        .start_slot(spec.epoch_length),
-                    &spec
-                )
-                .ok_or(AttestationValidationError::NoBlockRoot)?,
-        AttestationValidationError::WrongJustifiedRoot
-    );
-    let potential_crosslink = Crosslink {
-        shard_block_root: attestation.data.shard_block_root,
-        epoch: attestation.data.slot.epoch(spec.epoch_length),
-    };
-    ensure!(
-        (attestation.data.latest_crosslink
-            == state.latest_crosslinks[attestation.data.shard as usize])
-            | (attestation.data.latest_crosslink == potential_crosslink),
-        AttestationValidationError::BadLatestCrosslinkRoot
-    );
-    if verify_signature {
-        let participants = state.get_attestation_participants(
-            &attestation.data,
-            &attestation.aggregation_bitfield,
-            spec,
-        )?;
-        let mut group_public_key = AggregatePublicKey::new();
-        for participant in participants {
-            group_public_key.add(
-                state.validator_registry[participant as usize]
-                    .pubkey
-                    .as_raw(),
-            )
-        }
-        ensure!(
-            attestation.verify_signature(
-                &group_public_key,
-                PHASE_0_CUSTODY_BIT,
-                get_domain(
-                    &state.fork,
-                    attestation.data.slot.epoch(spec.epoch_length),
-                    DOMAIN_ATTESTATION,
-                )
-            ),
-            AttestationValidationError::BadSignature
-        );
-    }
-    ensure!(
-        attestation.data.shard_block_root == spec.zero_hash,
-        AttestationValidationError::ShardBlockRootNotZero
-    );
-    Ok(())
-}
-
-fn get_domain(_fork: &Fork, _epoch: Epoch, _domain_type: u64) -> u64 {
-    // TODO: stubbed out.
-    0
-}
-
-fn bls_verify(pubkey: &PublicKey, message: &[u8], signature: &Signature, _domain: u64) -> bool {
-    // TODO: add domain
-    signature.verify(message, pubkey)
-}
-
-impl From<AttestationValidationError> for Error {
-    fn from(e: AttestationValidationError) -> Error {
-        Error::InvalidAttestation(e)
-    }
-}
-
-impl From<CommitteesError> for Error {
-    fn from(e: CommitteesError) -> Error {
-        Error::CommitteesError(e)
-    }
-}
-
-impl From<SlotProcessingError> for Error {
-    fn from(e: SlotProcessingError) -> Error {
-        Error::SlotProcessingError(e)
-    }
-}

eth2/state_processing/src/epoch_processable.rs

@@ -1,716 +0,0 @@
-use integer_sqrt::IntegerSquareRoot;
-use log::{debug, trace};
-use rayon::prelude::*;
-use ssz::TreeHash;
-use std::collections::{HashMap, HashSet};
-use std::iter::FromIterator;
-use types::{
-    beacon_state::{AttestationParticipantsError, CommitteesError, InclusionError},
-    validator_registry::get_active_validator_indices,
-    BeaconState, ChainSpec, Crosslink, Epoch, Hash256, PendingAttestation,
-};
-
-macro_rules! safe_add_assign {
-    ($a: expr, $b: expr) => {
-        $a = $a.saturating_add($b);
-    };
-}
-macro_rules! safe_sub_assign {
-    ($a: expr, $b: expr) => {
-        $a = $a.saturating_sub($b);
-    };
-}
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    UnableToDetermineProducer,
-    NoBlockRoots,
-    BaseRewardQuotientIsZero,
-    NoRandaoSeed,
-    CommitteesError(CommitteesError),
-    AttestationParticipantsError(AttestationParticipantsError),
-    InclusionError(InclusionError),
-    WinningRootError(WinningRootError),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum WinningRootError {
-    NoWinningRoot,
-    AttestationParticipantsError(AttestationParticipantsError),
-}
-
-#[derive(Clone)]
-pub struct WinningRoot {
-    pub shard_block_root: Hash256,
-    pub attesting_validator_indices: Vec<usize>,
-    pub total_balance: u64,
-    pub total_attesting_balance: u64,
-}
-
-pub trait EpochProcessable {
-    fn per_epoch_processing(&mut self, spec: &ChainSpec) -> Result<(), Error>;
-}
-
-impl EpochProcessable for BeaconState {
-    // Cyclomatic complexity is ignored. It would be ideal to split this function apart, however it
-    // remains monolithic to allow for easier spec updates. Once the spec is more stable we can
-    // optimise.
-    #[allow(clippy::cyclomatic_complexity)]
-    fn per_epoch_processing(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-        let previous_epoch = self.previous_epoch(spec);
-        let next_epoch = self.next_epoch(spec);
-
-        debug!(
-            "Starting per-epoch processing on epoch {}...",
-            self.current_epoch(spec)
-        );
-
-        /*
-         * Validators attesting during the current epoch.
-         */
-        let active_validator_indices = get_active_validator_indices(
-            &self.validator_registry,
-            self.slot.epoch(spec.epoch_length),
-        );
-        let current_total_balance = self.get_total_balance(&active_validator_indices[..], spec);
-
-        trace!(
-            "{} validators with a total balance of {} wei.",
-            active_validator_indices.len(),
-            current_total_balance
-        );
-
-        let current_epoch_attestations: Vec<&PendingAttestation> = self
-            .latest_attestations
-            .par_iter()
-            .filter(|a| {
-                (a.data.slot / spec.epoch_length).epoch(spec.epoch_length)
-                    == self.current_epoch(spec)
-            })
-            .collect();
-
-        trace!(
-            "Current epoch attestations: {}",
-            current_epoch_attestations.len()
-        );
-
-        let current_epoch_boundary_attestations: Vec<&PendingAttestation> =
-            current_epoch_attestations
-                .par_iter()
-                .filter(
-                    |a| match self.get_block_root(self.current_epoch_start_slot(spec), spec) {
-                        Some(block_root) => {
-                            (a.data.epoch_boundary_root == *block_root)
-                                && (a.data.justified_epoch == self.justified_epoch)
-                        }
-                        None => unreachable!(),
-                    },
-                )
-                .cloned()
-                .collect();
-
-        let current_epoch_boundary_attester_indices = self
-            .get_attestation_participants_union(&current_epoch_boundary_attestations[..], spec)?;
-        let current_epoch_boundary_attesting_balance =
-            self.get_total_balance(&current_epoch_boundary_attester_indices[..], spec);
-
-        trace!(
-            "Current epoch boundary attesters: {}",
-            current_epoch_boundary_attester_indices.len()
-        );
-
-        /*
-         * Validators attesting during the previous epoch
-         */
-
-        /*
-         * Validators that made an attestation during the previous epoch
-         */
-        let previous_epoch_attestations: Vec<&PendingAttestation> = self
-            .latest_attestations
-            .par_iter()
-            .filter(|a| {
-                //TODO: ensure these saturating subs are correct.
-                (a.data.slot / spec.epoch_length).epoch(spec.epoch_length)
-                    == self.previous_epoch(spec)
-            })
-            .collect();
-
-        debug!(
-            "previous epoch attestations: {}",
-            previous_epoch_attestations.len()
-        );
-
-        let previous_epoch_attester_indices =
-            self.get_attestation_participants_union(&previous_epoch_attestations[..], spec)?;
-        let previous_total_balance =
-            self.get_total_balance(&previous_epoch_attester_indices[..], spec);
-
-        /*
-         * Validators targetting the previous justified slot
-         */
-        let previous_epoch_justified_attestations: Vec<&PendingAttestation> = {
-            let mut a: Vec<&PendingAttestation> = current_epoch_attestations
-                .iter()
-                .filter(|a| a.data.justified_epoch == self.previous_justified_epoch)
-                .cloned()
-                .collect();
-            let mut b: Vec<&PendingAttestation> = previous_epoch_attestations
-                .iter()
-                .filter(|a| a.data.justified_epoch == self.previous_justified_epoch)
-                .cloned()
-                .collect();
-            a.append(&mut b);
-            a
-        };
-
-        let previous_epoch_justified_attester_indices = self
-            .get_attestation_participants_union(&previous_epoch_justified_attestations[..], spec)?;
-        let previous_epoch_justified_attesting_balance =
-            self.get_total_balance(&previous_epoch_justified_attester_indices[..], spec);
-
-        /*
-         * Validators justifying the epoch boundary block at the start of the previous epoch
-         */
-        let previous_epoch_boundary_attestations: Vec<&PendingAttestation> =
-            previous_epoch_justified_attestations
-                .iter()
-                .filter(
-                    |a| match self.get_block_root(self.previous_epoch_start_slot(spec), spec) {
-                        Some(block_root) => a.data.epoch_boundary_root == *block_root,
-                        None => unreachable!(),
-                    },
-                )
-                .cloned()
-                .collect();
-
-        let previous_epoch_boundary_attester_indices = self
-            .get_attestation_participants_union(&previous_epoch_boundary_attestations[..], spec)?;
-        let previous_epoch_boundary_attesting_balance =
-            self.get_total_balance(&previous_epoch_boundary_attester_indices[..], spec);
-
-        /*
-         * Validators attesting to the expected beacon chain head during the previous epoch.
-         */
-        let previous_epoch_head_attestations: Vec<&PendingAttestation> =
-            previous_epoch_attestations
-                .iter()
-                .filter(|a| match self.get_block_root(a.data.slot, spec) {
-                    Some(block_root) => a.data.beacon_block_root == *block_root,
-                    None => unreachable!(),
-                })
-                .cloned()
-                .collect();
-
-        let previous_epoch_head_attester_indices =
-            self.get_attestation_participants_union(&previous_epoch_head_attestations[..], spec)?;
-        let previous_epoch_head_attesting_balance =
-            self.get_total_balance(&previous_epoch_head_attester_indices[..], spec);
-
-        debug!(
-            "previous_epoch_head_attester_balance of {} wei.",
-            previous_epoch_head_attesting_balance
-        );
-
-        /*
-         * Eth1 Data
-         */
-        if self.next_epoch(spec) % spec.eth1_data_voting_period == 0 {
-            for eth1_data_vote in &self.eth1_data_votes {
-                if eth1_data_vote.vote_count * 2 > spec.eth1_data_voting_period {
-                    self.latest_eth1_data = eth1_data_vote.eth1_data.clone();
-                }
-            }
-            self.eth1_data_votes = vec![];
-        }
-
-        /*
-         * Justification
-         */
-
-        let mut new_justified_epoch = self.justified_epoch;
-        self.justification_bitfield <<= 1;
-
-        // If > 2/3 of the total balance attested to the previous epoch boundary
-        //
-        // - Set the 2nd bit of the bitfield.
-        // - Set the previous epoch to be justified.
-        if (3 * previous_epoch_boundary_attesting_balance) >= (2 * current_total_balance) {
-            self.justification_bitfield |= 2;
-            new_justified_epoch = previous_epoch;
-            trace!(">= 2/3 voted for previous epoch boundary");
-        }
-        // If > 2/3 of the total balance attested to the previous epoch boundary
-        //
-        // - Set the 1st bit of the bitfield.
-        // - Set the current epoch to be justified.
-        if (3 * current_epoch_boundary_attesting_balance) >= (2 * current_total_balance) {
-            self.justification_bitfield |= 1;
-            new_justified_epoch = current_epoch;
-            trace!(">= 2/3 voted for current epoch boundary");
-        }
-
-        // If:
-        //
-        // - All three epochs prior to this epoch have been justified.
-        // - The previous justified justified epoch was three epochs ago.
-        //
-        // Then, set the finalized epoch to be three epochs ago.
-        if ((self.justification_bitfield >> 1) % 8 == 0b111)
-            & (self.previous_justified_epoch == previous_epoch - 2)
-        {
-            self.finalized_epoch = self.previous_justified_epoch;
-            trace!("epoch - 3 was finalized (1st condition).");
-        }
-        // If:
-        //
-        // - Both two epochs prior to this epoch have been justified.
-        // - The previous justified epoch was two epochs ago.
-        //
-        // Then, set the finalized epoch to two epochs ago.
-        if ((self.justification_bitfield >> 1) % 4 == 0b11)
-            & (self.previous_justified_epoch == previous_epoch - 1)
-        {
-            self.finalized_epoch = self.previous_justified_epoch;
-            trace!("epoch - 2 was finalized (2nd condition).");
-        }
-        // If:
-        //
-        // - This epoch and the two prior have been justified.
-        // - The presently justified epoch was two epochs ago.
-        //
-        // Then, set the finalized epoch to two epochs ago.
-        if (self.justification_bitfield % 8 == 0b111) & (self.justified_epoch == previous_epoch - 1)
-        {
-            self.finalized_epoch = self.justified_epoch;
-            trace!("epoch - 2 was finalized (3rd condition).");
-        }
-        // If:
-        //
-        // - This epoch and the epoch prior to it have been justified.
-        // - Set the previous epoch to be justified.
-        //
-        // Then, set the finalized epoch to be the previous epoch.
-        if (self.justification_bitfield % 4 == 0b11) & (self.justified_epoch == previous_epoch) {
-            self.finalized_epoch = self.justified_epoch;
-            trace!("epoch - 1 was finalized (4th condition).");
-        }
-
-        self.previous_justified_epoch = self.justified_epoch;
-        self.justified_epoch = new_justified_epoch;
-
-        debug!(
-            "Finalized epoch {}, justified epoch {}.",
-            self.finalized_epoch, self.justified_epoch
-        );
-
-        /*
-         * Crosslinks
-         */
-
-        // Cached for later lookups.
-        let mut winning_root_for_shards: HashMap<u64, Result<WinningRoot, WinningRootError>> =
-            HashMap::new();
-
-        // for slot in self.slot.saturating_sub(2 * spec.epoch_length)..self.slot {
-        for slot in self.previous_epoch(spec).slot_iter(spec.epoch_length) {
-            let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, false, spec)?;
-
-            for (crosslink_committee, shard) in crosslink_committees_at_slot {
-                let shard = shard as u64;
-
-                let winning_root = winning_root(
-                    self,
-                    shard,
-                    &current_epoch_attestations,
-                    &previous_epoch_attestations,
-                    spec,
-                );
-
-                if let Ok(winning_root) = &winning_root {
-                    let total_committee_balance =
-                        self.get_total_balance(&crosslink_committee[..], spec);
-
-                    if (3 * winning_root.total_attesting_balance) >= (2 * total_committee_balance) {
-                        self.latest_crosslinks[shard as usize] = Crosslink {
-                            epoch: current_epoch,
-                            shard_block_root: winning_root.shard_block_root,
-                        }
-                    }
-                }
-                winning_root_for_shards.insert(shard, winning_root);
-            }
-        }
-
-        trace!(
-            "Found {} winning shard roots.",
-            winning_root_for_shards.len()
-        );
-
-        /*
-         * Rewards and Penalities
-         */
-        let base_reward_quotient = previous_total_balance.integer_sqrt();
-        if base_reward_quotient == 0 {
-            return Err(Error::BaseRewardQuotientIsZero);
-        }
-
-        /*
-         * Justification and finalization
-         */
-        let epochs_since_finality = next_epoch - self.finalized_epoch;
-
-        let previous_epoch_justified_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_justified_attester_indices.iter().cloned());
-        let previous_epoch_boundary_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_boundary_attester_indices.iter().cloned());
-        let previous_epoch_head_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_head_attester_indices.iter().cloned());
-        let previous_epoch_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_attester_indices.iter().cloned());
-        let active_validator_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(active_validator_indices.iter().cloned());
-
-        debug!("previous epoch justified attesters: {}, previous epoch boundary attesters: {}, previous epoch head attesters: {}, previous epoch attesters: {}", previous_epoch_justified_attester_indices.len(), previous_epoch_boundary_attester_indices.len(), previous_epoch_head_attester_indices.len(), previous_epoch_attester_indices.len());
-
-        debug!("{} epochs since finality.", epochs_since_finality);
-
-        if epochs_since_finality <= 4 {
-            for index in 0..self.validator_balances.len() {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-
-                if previous_epoch_justified_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_justified_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-
-                if previous_epoch_boundary_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_boundary_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-
-                if previous_epoch_head_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_head_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-            }
-
-            for index in previous_epoch_attester_indices {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                let inclusion_distance =
-                    self.inclusion_distance(&previous_epoch_attestations, index, spec)?;
-
-                safe_add_assign!(
-                    self.validator_balances[index],
-                    base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
-                )
-            }
-        } else {
-            for index in 0..self.validator_balances.len() {
-                let inactivity_penalty = self.inactivity_penalty(
-                    index,
-                    epochs_since_finality,
-                    base_reward_quotient,
-                    spec,
-                );
-                if active_validator_indices_hashset.contains(&index) {
-                    if !previous_epoch_justified_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-                    if !previous_epoch_boundary_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-                    if !previous_epoch_head_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-
-                    if self.validator_registry[index].penalized_epoch <= current_epoch {
-                        let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                        safe_sub_assign!(
-                            self.validator_balances[index],
-                            2 * inactivity_penalty + base_reward
-                        );
-                    }
-                }
-            }
-
-            for index in previous_epoch_attester_indices {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                let inclusion_distance =
-                    self.inclusion_distance(&previous_epoch_attestations, index, spec)?;
-
-                safe_sub_assign!(
-                    self.validator_balances[index],
-                    base_reward
-                        - base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
-                );
-            }
-        }
-
-        trace!("Processed validator justification and finalization rewards/penalities.");
-
-        /*
-         * Attestation inclusion
-         */
-        for &index in &previous_epoch_attester_indices_hashset {
-            let inclusion_slot =
-                self.inclusion_slot(&previous_epoch_attestations[..], index, spec)?;
-            let proposer_index = self
-                .get_beacon_proposer_index(inclusion_slot, spec)
-                .map_err(|_| Error::UnableToDetermineProducer)?;
-            let base_reward = self.base_reward(proposer_index, base_reward_quotient, spec);
-            safe_add_assign!(
-                self.validator_balances[proposer_index],
-                base_reward / spec.includer_reward_quotient
-            );
-        }
-
-        trace!(
-            "Previous epoch attesters: {}.",
-            previous_epoch_attester_indices_hashset.len()
-        );
-
-        /*
-         * Crosslinks
-         */
-        for slot in self.previous_epoch(spec).slot_iter(spec.epoch_length) {
-            let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, false, spec)?;
-
-            for (_crosslink_committee, shard) in crosslink_committees_at_slot {
-                let shard = shard as u64;
-
-                if let Some(Ok(winning_root)) = winning_root_for_shards.get(&shard) {
-                    // TODO: remove the map.
-                    let attesting_validator_indices: HashSet<usize> = HashSet::from_iter(
-                        winning_root.attesting_validator_indices.iter().cloned(),
-                    );
-
-                    for index in 0..self.validator_balances.len() {
-                        let base_reward = self.base_reward(index, base_reward_quotient, spec);
-
-                        if attesting_validator_indices.contains(&index) {
-                            safe_add_assign!(
-                                self.validator_balances[index],
-                                base_reward * winning_root.total_attesting_balance
-                                    / winning_root.total_balance
-                            );
-                        } else {
-                            safe_sub_assign!(self.validator_balances[index], base_reward);
-                        }
-                    }
-
-                    for index in &winning_root.attesting_validator_indices {
-                        let base_reward = self.base_reward(*index, base_reward_quotient, spec);
-                        safe_add_assign!(
-                            self.validator_balances[*index],
-                            base_reward * winning_root.total_attesting_balance
-                                / winning_root.total_balance
-                        );
-                    }
-                }
-            }
-        }
-
-        /*
-         * Ejections
-         */
-        self.process_ejections(spec);
-
-        /*
-         * Validator Registry
-         */
-        self.previous_calculation_epoch = self.current_calculation_epoch;
-        self.previous_epoch_start_shard = self.current_epoch_start_shard;
-        self.previous_epoch_seed = self.current_epoch_seed;
-
-        let should_update_validator_registy = if self.finalized_epoch
-            > self.validator_registry_update_epoch
-        {
-            (0..self.get_current_epoch_committee_count(spec)).all(|i| {
-                let shard = (self.current_epoch_start_shard + i as u64) % spec.shard_count;
-                self.latest_crosslinks[shard as usize].epoch > self.validator_registry_update_epoch
-            })
-        } else {
-            false
-        };
-
-        if should_update_validator_registy {
-            self.update_validator_registry(spec);
-
-            self.current_calculation_epoch = next_epoch;
-            self.current_epoch_start_shard = (self.current_epoch_start_shard
-                + self.get_current_epoch_committee_count(spec) as u64)
-                % spec.shard_count;
-            self.current_epoch_seed = self
-                .generate_seed(self.current_calculation_epoch, spec)
-                .ok_or_else(|| Error::NoRandaoSeed)?;
-        } else {
-            let epochs_since_last_registry_update =
-                current_epoch - self.validator_registry_update_epoch;
-            if (epochs_since_last_registry_update > 1)
-                & epochs_since_last_registry_update.is_power_of_two()
-            {
-                self.current_calculation_epoch = next_epoch;
-                self.current_epoch_seed = self
-                    .generate_seed(self.current_calculation_epoch, spec)
-                    .ok_or_else(|| Error::NoRandaoSeed)?;
-            }
-        }
-
-        self.process_penalties_and_exits(spec);
-
-        self.latest_index_roots[(next_epoch.as_usize() + spec.entry_exit_delay as usize)
-            % spec.latest_index_roots_length] = hash_tree_root(get_active_validator_indices(
-            &self.validator_registry,
-            next_epoch + Epoch::from(spec.entry_exit_delay),
-        ));
-        self.latest_penalized_balances[next_epoch.as_usize() % spec.latest_penalized_exit_length] =
-            self.latest_penalized_balances
-                [current_epoch.as_usize() % spec.latest_penalized_exit_length];
-        self.latest_randao_mixes[next_epoch.as_usize() % spec.latest_randao_mixes_length] = self
-            .get_randao_mix(current_epoch, spec)
-            .and_then(|x| Some(*x))
-            .ok_or_else(|| Error::NoRandaoSeed)?;
-        self.latest_attestations = self
-            .latest_attestations
-            .iter()
-            .filter(|a| a.data.slot.epoch(spec.epoch_length) >= current_epoch)
-            .cloned()
-            .collect();
-
-        debug!("Epoch transition complete.");
-
-        Ok(())
-    }
-}
-
-fn hash_tree_root<T: TreeHash>(input: Vec<T>) -> Hash256 {
-    Hash256::from(&input.hash_tree_root()[..])
-}
-
-fn winning_root(
-    state: &BeaconState,
-    shard: u64,
-    current_epoch_attestations: &[&PendingAttestation],
-    previous_epoch_attestations: &[&PendingAttestation],
-    spec: &ChainSpec,
-) -> Result<WinningRoot, WinningRootError> {
-    let mut attestations = current_epoch_attestations.to_vec();
-    attestations.append(&mut previous_epoch_attestations.to_vec());
-
-    let mut candidates: HashMap<Hash256, WinningRoot> = HashMap::new();
-
-    let mut highest_seen_balance = 0;
-
-    for a in &attestations {
-        if a.data.shard != shard {
-            continue;
-        }
-
-        let shard_block_root = &a.data.shard_block_root;
-
-        if candidates.contains_key(shard_block_root) {
-            continue;
-        }
-
-        // TODO: `cargo fmt` makes this rather ugly; tidy up.
-        let attesting_validator_indices = attestations.iter().try_fold::<_, _, Result<
-            _,
-            AttestationParticipantsError,
-        >>(vec![], |mut acc, a| {
-            if (a.data.shard == shard) && (a.data.shard_block_root == *shard_block_root) {
-                acc.append(&mut state.get_attestation_participants(
-                    &a.data,
-                    &a.aggregation_bitfield,
-                    spec,
-                )?);
-            }
-            Ok(acc)
-        })?;
-
-        let total_balance: u64 = attesting_validator_indices
-            .iter()
-            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
-
-        let total_attesting_balance: u64 = attesting_validator_indices
-            .iter()
-            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
-
-        if total_attesting_balance > highest_seen_balance {
-            highest_seen_balance = total_attesting_balance;
-        }
-
-        let candidate_root = WinningRoot {
-            shard_block_root: *shard_block_root,
-            attesting_validator_indices,
-            total_attesting_balance,
-            total_balance,
-        };
-
-        candidates.insert(*shard_block_root, candidate_root);
-    }
-
-    Ok(candidates
-        .iter()
-        .filter_map(|(_hash, candidate)| {
-            if candidate.total_attesting_balance == highest_seen_balance {
-                Some(candidate)
-            } else {
-                None
-            }
-        })
-        .min_by_key(|candidate| candidate.shard_block_root)
-        .ok_or_else(|| WinningRootError::NoWinningRoot)?
-        // TODO: avoid clone.
-        .clone())
-}
-
-impl From<InclusionError> for Error {
-    fn from(e: InclusionError) -> Error {
-        Error::InclusionError(e)
-    }
-}
-
-impl From<CommitteesError> for Error {
-    fn from(e: CommitteesError) -> Error {
-        Error::CommitteesError(e)
-    }
-}
-
-impl From<AttestationParticipantsError> for Error {
-    fn from(e: AttestationParticipantsError) -> Error {
-        Error::AttestationParticipantsError(e)
-    }
-}
-
-impl From<AttestationParticipantsError> for WinningRootError {
-    fn from(e: AttestationParticipantsError) -> WinningRootError {
-        WinningRootError::AttestationParticipantsError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}

eth2/state_processing/src/lib.rs

@@ -1,10 +0,0 @@
-mod block_processable;
-mod epoch_processable;
-mod slot_processable;
-
-pub use block_processable::{
-    validate_attestation, validate_attestation_without_signature, BlockProcessable,
-    Error as BlockProcessingError,
-};
-pub use epoch_processable::{EpochProcessable, Error as EpochProcessingError};
-pub use slot_processable::{Error as SlotProcessingError, SlotProcessable};

eth2/state_processing/src/slot_processable.rs

@@ -1,70 +0,0 @@
-use crate::{EpochProcessable, EpochProcessingError};
-use types::{beacon_state::CommitteesError, BeaconState, ChainSpec, Hash256};
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    CommitteesError(CommitteesError),
-    EpochProcessingError(EpochProcessingError),
-}
-
-pub trait SlotProcessable {
-    fn per_slot_processing(
-        &mut self,
-        previous_block_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), Error>;
-}
-
-impl SlotProcessable for BeaconState
-where
-    BeaconState: EpochProcessable,
-{
-    fn per_slot_processing(
-        &mut self,
-        previous_block_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        if (self.slot + 1) % spec.epoch_length == 0 {
-            self.per_epoch_processing(spec)?;
-        }
-
-        self.slot += 1;
-
-        self.latest_randao_mixes[self.slot.as_usize() % spec.latest_randao_mixes_length] =
-            self.latest_randao_mixes[(self.slot.as_usize() - 1) % spec.latest_randao_mixes_length];
-
-        // Block roots.
-        self.latest_block_roots[(self.slot.as_usize() - 1) % spec.latest_block_roots_length] =
-            previous_block_root;
-
-        if self.slot.as_usize() % spec.latest_block_roots_length == 0 {
-            let root = merkle_root(&self.latest_block_roots[..]);
-            self.batched_block_roots.push(root);
-        }
-        Ok(())
-    }
-}
-
-fn merkle_root(_input: &[Hash256]) -> Hash256 {
-    Hash256::zero()
-}
-
-impl From<CommitteesError> for Error {
-    fn from(e: CommitteesError) -> Error {
-        Error::CommitteesError(e)
-    }
-}
-
-impl From<EpochProcessingError> for Error {
-    fn from(e: EpochProcessingError) -> Error {
-        Error::EpochProcessingError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}

eth2/types/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "types"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-bls = { path = "../utils/bls" }
-boolean-bitfield = { path = "../utils/boolean-bitfield" }
-ethereum-types = "0.4.0"
-hashing = { path = "../utils/hashing" }
-honey-badger-split =  { path = "../utils/honey-badger-split" }
-log = "0.4"
-rayon = "1.0"
-rand = "0.5.5"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-slog = "^2.2.3"
-ssz = { path = "../utils/ssz" }
-vec_shuffle = { path = "../utils/vec_shuffle" }

eth2/types/src/attestation.rs

@@ -1,112 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/// 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

@@ -1,75 +0,0 @@
-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;
-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::{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

@@ -1,93 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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.rs

@@ -1,716 +0,0 @@
-/// The `Slot` and `Epoch` types are defined as newtypes over u64 to enforce type-safety between
-/// the two types.
-///
-/// `Slot` and `Epoch` 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` and `Epochs` 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
-            }
-        }
-    };
-}
-
-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);
-    };
-}
-
-#[derive(Eq, Debug, Clone, Copy, Default, Serialize)]
-pub struct Slot(u64);
-
-#[derive(Eq, Debug, Clone, Copy, Default, Serialize)]
-pub struct Epoch(u64);
-
-impl_common!(Slot);
-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 max_value() -> Slot {
-        Slot(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

@@ -1,111 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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

@@ -1,172 +0,0 @@
-/// 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

@@ -1,113 +0,0 @@
-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
-    }
-}

eth2/utils/bls/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "bls"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-bls-aggregates = { git = "https://github.com/sigp/signature-schemes", tag = "v0.3.0" }
-hashing = { path = "../hashing" }
-hex = "0.3"
-serde = "1.0"
-ssz = { path = "../ssz" }

eth2/utils/bls/src/aggregate_signature.rs

@@ -1,83 +0,0 @@
-use super::{AggregatePublicKey, Signature};
-use bls_aggregates::AggregateSignature as RawAggregateSignature;
-use serde::ser::{Serialize, Serializer};
-use ssz::{
-    decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
-};
-
-/// A BLS aggregate signature.
-///
-/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
-/// serialization).
-#[derive(Debug, PartialEq, Clone, Default, Eq)]
-pub struct AggregateSignature(RawAggregateSignature);
-
-impl AggregateSignature {
-    /// Instantiate a new AggregateSignature.
-    pub fn new() -> Self {
-        AggregateSignature(RawAggregateSignature::new())
-    }
-
-    /// Add (aggregate) a signature to the `AggregateSignature`.
-    pub fn add(&mut self, signature: &Signature) {
-        self.0.add(signature.as_raw())
-    }
-
-    /// Verify the `AggregateSignature` against an `AggregatePublicKey`.
-    ///
-    /// Only returns `true` if the set of keys in the `AggregatePublicKey` match the set of keys
-    /// that signed the `AggregateSignature`.
-    pub fn verify(&self, msg: &[u8], aggregate_public_key: &AggregatePublicKey) -> bool {
-        self.0.verify(msg, aggregate_public_key)
-    }
-}
-
-impl Encodable for AggregateSignature {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.0.as_bytes());
-    }
-}
-
-impl Decodable for AggregateSignature {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (sig_bytes, i) = decode_ssz_list(bytes, i)?;
-        let raw_sig =
-            RawAggregateSignature::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?;
-        Ok((AggregateSignature(raw_sig), i))
-    }
-}
-
-impl Serialize for AggregateSignature {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(&ssz_encode(self))
-    }
-}
-
-impl TreeHash for AggregateSignature {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        hash(&self.0.as_bytes())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::{Keypair, Signature};
-    use super::*;
-    use ssz::ssz_encode;
-
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let keypair = Keypair::random();
-
-        let mut original = AggregateSignature::new();
-        original.add(&Signature::new(&[42, 42], &keypair.sk));
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = AggregateSignature::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-}

eth2/utils/bls/src/keypair.rs

@@ -1,16 +0,0 @@
-use super::{PublicKey, SecretKey};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Keypair {
-    pub sk: SecretKey,
-    pub pk: PublicKey,
-}
-
-impl Keypair {
-    /// Instantiate a Keypair using SecretKey::random().
-    pub fn random() -> Self {
-        let sk = SecretKey::random();
-        let pk = PublicKey::from_secret_key(&sk);
-        Keypair { sk, pk }
-    }
-}

eth2/utils/bls/src/lib.rs

@@ -1,52 +0,0 @@
-extern crate bls_aggregates;
-extern crate hashing;
-extern crate ssz;
-
-mod aggregate_signature;
-mod keypair;
-mod public_key;
-mod secret_key;
-mod signature;
-
-pub use crate::aggregate_signature::AggregateSignature;
-pub use crate::keypair::Keypair;
-pub use crate::public_key::PublicKey;
-pub use crate::secret_key::SecretKey;
-pub use crate::signature::Signature;
-
-pub use self::bls_aggregates::AggregatePublicKey;
-
-pub const BLS_AGG_SIG_BYTE_SIZE: usize = 97;
-
-use hashing::hash;
-use ssz::ssz_encode;
-use std::default::Default;
-
-fn extend_if_needed(hash: &mut Vec<u8>) {
-    // NOTE: bls_aggregates crate demands 48 bytes, this may be removed as we get closer to production
-    hash.resize(48, Default::default())
-}
-
-/// For some signature and public key, ensure that the signature message was the public key and it
-/// was signed by the secret key that corresponds to that public key.
-pub fn verify_proof_of_possession(sig: &Signature, pubkey: &PublicKey) -> bool {
-    let mut hash = hash(&ssz_encode(pubkey));
-    extend_if_needed(&mut hash);
-    sig.verify_hashed(&hash, &pubkey)
-}
-
-pub fn create_proof_of_possession(keypair: &Keypair) -> Signature {
-    let mut hash = hash(&ssz_encode(&keypair.pk));
-    extend_if_needed(&mut hash);
-    Signature::new_hashed(&hash, &keypair.sk)
-}
-
-pub fn bls_verify_aggregate(
-    pubkey: &AggregatePublicKey,
-    message: &[u8],
-    signature: &AggregateSignature,
-    _domain: u64,
-) -> bool {
-    // TODO: add domain
-    signature.verify(message, pubkey)
-}

eth2/utils/bls/src/public_key.rs

@@ -1,101 +0,0 @@
-use super::SecretKey;
-use bls_aggregates::PublicKey as RawPublicKey;
-use hex::encode as hex_encode;
-use serde::ser::{Serialize, Serializer};
-use ssz::{
-    decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
-};
-use std::default;
-use std::hash::{Hash, Hasher};
-
-/// A single BLS signature.
-///
-/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
-/// serialization).
-#[derive(Debug, Clone, Eq)]
-pub struct PublicKey(RawPublicKey);
-
-impl PublicKey {
-    pub fn from_secret_key(secret_key: &SecretKey) -> Self {
-        PublicKey(RawPublicKey::from_secret_key(secret_key.as_raw()))
-    }
-
-    /// Returns the underlying signature.
-    pub fn as_raw(&self) -> &RawPublicKey {
-        &self.0
-    }
-
-    /// Returns the last 6 bytes of the SSZ encoding of the public key, as a hex string.
-    ///
-    /// Useful for providing a short identifier to the user.
-    pub fn concatenated_hex_id(&self) -> String {
-        let bytes = ssz_encode(self);
-        let end_bytes = &bytes[bytes.len().saturating_sub(6)..bytes.len()];
-        hex_encode(end_bytes)
-    }
-}
-
-impl default::Default for PublicKey {
-    fn default() -> Self {
-        let secret_key = SecretKey::random();
-        PublicKey::from_secret_key(&secret_key)
-    }
-}
-
-impl Encodable for PublicKey {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.0.as_bytes());
-    }
-}
-
-impl Decodable for PublicKey {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (sig_bytes, i) = decode_ssz_list(bytes, i)?;
-        let raw_sig = RawPublicKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?;
-        Ok((PublicKey(raw_sig), i))
-    }
-}
-
-impl Serialize for PublicKey {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(&ssz_encode(self))
-    }
-}
-
-impl TreeHash for PublicKey {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        hash(&self.0.as_bytes())
-    }
-}
-
-impl PartialEq for PublicKey {
-    fn eq(&self, other: &PublicKey) -> bool {
-        ssz_encode(self) == ssz_encode(other)
-    }
-}
-
-impl Hash for PublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        ssz_encode(self).hash(state)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ssz::ssz_encode;
-
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let sk = SecretKey::random();
-        let original = PublicKey::from_secret_key(&sk);
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = PublicKey::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-}

eth2/utils/bls/src/secret_key.rs

@@ -1,65 +0,0 @@
-use bls_aggregates::{DecodeError as BlsDecodeError, SecretKey as RawSecretKey};
-use ssz::{decode_ssz_list, Decodable, DecodeError, Encodable, SszStream, TreeHash};
-
-/// A single BLS signature.
-///
-/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
-/// serialization).
-#[derive(Debug, PartialEq, Clone, Eq)]
-pub struct SecretKey(RawSecretKey);
-
-impl SecretKey {
-    pub fn random() -> Self {
-        SecretKey(RawSecretKey::random())
-    }
-
-    /// Instantiate a SecretKey from existing bytes.
-    ///
-    /// Note: this is _not_ SSZ decoding.
-    pub fn from_bytes(bytes: &[u8]) -> Result<SecretKey, BlsDecodeError> {
-        Ok(SecretKey(RawSecretKey::from_bytes(bytes)?))
-    }
-
-    /// Returns the underlying secret key.
-    pub fn as_raw(&self) -> &RawSecretKey {
-        &self.0
-    }
-}
-
-impl Encodable for SecretKey {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.0.as_bytes());
-    }
-}
-
-impl Decodable for SecretKey {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (sig_bytes, i) = decode_ssz_list(bytes, i)?;
-        let raw_sig = RawSecretKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?;
-        Ok((SecretKey(raw_sig), i))
-    }
-}
-
-impl TreeHash for SecretKey {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        self.0.as_bytes().clone()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ssz::ssz_encode;
-
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let original =
-            SecretKey::from_bytes("jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj".as_bytes())
-                .unwrap();
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = SecretKey::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-}

eth2/utils/bls/src/signature.rs

@@ -1,107 +0,0 @@
-use super::{PublicKey, SecretKey};
-use bls_aggregates::Signature as RawSignature;
-use serde::ser::{Serialize, Serializer};
-use ssz::{
-    decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
-};
-
-/// A single BLS signature.
-///
-/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
-/// serialization).
-#[derive(Debug, PartialEq, Clone, Eq)]
-pub struct Signature(RawSignature);
-
-impl Signature {
-    /// Instantiate a new Signature from a message and a SecretKey.
-    pub fn new(msg: &[u8], sk: &SecretKey) -> Self {
-        Signature(RawSignature::new(msg, sk.as_raw()))
-    }
-
-    /// Instantiate a new Signature from a message and a SecretKey, where the message has already
-    /// been hashed.
-    pub fn new_hashed(msg_hashed: &[u8], sk: &SecretKey) -> Self {
-        Signature(RawSignature::new_hashed(msg_hashed, sk.as_raw()))
-    }
-
-    /// Verify the Signature against a PublicKey.
-    pub fn verify(&self, msg: &[u8], pk: &PublicKey) -> bool {
-        self.0.verify(msg, pk.as_raw())
-    }
-
-    /// Verify the Signature against a PublicKey, where the message has already been hashed.
-    pub fn verify_hashed(&self, msg_hash: &[u8], pk: &PublicKey) -> bool {
-        self.0.verify_hashed(msg_hash, pk.as_raw())
-    }
-
-    /// Returns the underlying signature.
-    pub fn as_raw(&self) -> &RawSignature {
-        &self.0
-    }
-
-    /// Returns a new empty signature.
-    pub fn empty_signature() -> Self {
-        let empty: Vec<u8> = vec![0; 97];
-        Signature(RawSignature::from_bytes(&empty).unwrap())
-    }
-}
-
-impl Encodable for Signature {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.0.as_bytes());
-    }
-}
-
-impl Decodable for Signature {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (sig_bytes, i) = decode_ssz_list(bytes, i)?;
-        let raw_sig = RawSignature::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?;
-        Ok((Signature(raw_sig), i))
-    }
-}
-
-impl TreeHash for Signature {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        hash(&self.0.as_bytes())
-    }
-}
-
-impl Serialize for Signature {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(&ssz_encode(self))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::Keypair;
-    use super::*;
-    use ssz::ssz_encode;
-
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let keypair = Keypair::random();
-
-        let original = Signature::new(&[42, 42], &keypair.sk);
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = Signature::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    pub fn test_empty_signature() {
-        let sig = Signature::empty_signature();
-
-        let sig_as_bytes: Vec<u8> = sig.as_raw().as_bytes();
-
-        assert_eq!(sig_as_bytes.len(), 97);
-        for one_byte in sig_as_bytes.iter() {
-            assert_eq!(*one_byte, 0);
-        }
-    }
-}

eth2/utils/boolean-bitfield/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "boolean-bitfield"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-ssz = { path = "../ssz" }
-bit-vec = "0.5.0"
-serde = "1.0"
-serde_derive = "1.0"

eth2/utils/boolean-bitfield/README.md

@@ -1,3 +0,0 @@
-# Boolean Bitfield
-
-Implements a set of boolean as a tightly-packed vector of bits.

eth2/utils/boolean-bitfield/src/lib.rs

@@ -1,413 +0,0 @@
-extern crate bit_vec;
-extern crate ssz;
-
-use bit_vec::BitVec;
-
-use serde::ser::{Serialize, Serializer};
-use std::cmp;
-use std::default;
-
-/// A BooleanBitfield represents a set of booleans compactly stored as a vector of bits.
-/// The BooleanBitfield is given a fixed size during construction. Reads outside of the current size return an out-of-bounds error. Writes outside of the current size expand the size of the set.
-#[derive(Debug, Clone)]
-pub struct BooleanBitfield(BitVec);
-
-/// Error represents some reason a request against a bitfield was not satisfied
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    /// OutOfBounds refers to indexing into a bitfield where no bits exist; returns the illegal index and the current size of the bitfield, respectively
-    OutOfBounds(usize, usize),
-}
-
-impl BooleanBitfield {
-    /// Create a new bitfield.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn with_capacity(initial_len: usize) -> Self {
-        Self::from_elem(initial_len, false)
-    }
-
-    /// Create a new bitfield with the given length `initial_len` and all values set to `bit`.
-    pub fn from_elem(inital_len: usize, bit: bool) -> Self {
-        Self {
-            0: BitVec::from_elem(inital_len, bit),
-        }
-    }
-
-    /// Create a new bitfield using the supplied `bytes` as input
-    pub fn from_bytes(bytes: &[u8]) -> Self {
-        Self {
-            0: BitVec::from_bytes(bytes),
-        }
-    }
-
-    /// Read the value of a bit.
-    ///
-    /// If the index is in bounds, then result is Ok(value) where value is `true` if the bit is 1 and `false` if the bit is 0.
-    /// If the index is out of bounds, we return an error to that extent.
-    pub fn get(&self, i: usize) -> Result<bool, Error> {
-        match self.0.get(i) {
-            Some(value) => Ok(value),
-            None => Err(Error::OutOfBounds(i, self.0.len())),
-        }
-    }
-
-    /// Set the value of a bit.
-    ///
-    /// If the index is out of bounds, we expand the size of the underlying set to include the new index.
-    /// Returns the previous value if there was one.
-    pub fn set(&mut self, i: usize, value: bool) -> Option<bool> {
-        let previous = match self.get(i) {
-            Ok(previous) => Some(previous),
-            Err(Error::OutOfBounds(_, len)) => {
-                let new_len = i - len + 1;
-                self.0.grow(new_len, false);
-                None
-            }
-        };
-        self.0.set(i, value);
-        previous
-    }
-
-    /// Returns the index of the highest set bit. Some(n) if some bit is set, None otherwise.
-    pub fn highest_set_bit(&self) -> Option<usize> {
-        self.0.iter().rposition(|bit| bit)
-    }
-
-    /// Returns the number of bits in this bitfield.
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    /// Returns true if `self.len() == 0`
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Returns the number of bytes required to represent this bitfield.
-    pub fn num_bytes(&self) -> usize {
-        self.to_bytes().len()
-    }
-
-    /// Returns the number of `1` bits in the bitfield
-    pub fn num_set_bits(&self) -> usize {
-        self.0.iter().filter(|&bit| bit).count()
-    }
-
-    /// Returns a vector of bytes representing the bitfield
-    /// Note that this returns the bit layout of the underlying implementation in the `bit-vec` crate.
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.0.to_bytes()
-    }
-}
-
-impl default::Default for BooleanBitfield {
-    /// default provides the "empty" bitfield
-    /// Note: the empty bitfield is set to the `0` byte.
-    fn default() -> Self {
-        Self::from_elem(8, false)
-    }
-}
-
-impl cmp::PartialEq for BooleanBitfield {
-    /// Determines equality by comparing the `ssz` encoding of the two candidates.
-    /// This method ensures that the presence of high-order (empty) bits in the highest byte do not exclude equality when they are in fact representing the same information.
-    fn eq(&self, other: &Self) -> bool {
-        ssz::ssz_encode(self) == ssz::ssz_encode(other)
-    }
-}
-
-/// Create a new bitfield that is a union of two other bitfields.
-///
-/// For example `union(0101, 1000) == 1101`
-impl std::ops::BitAnd for BooleanBitfield {
-    type Output = Self;
-
-    fn bitand(self, other: Self) -> Self {
-        let (biggest, smallest) = if self.len() > other.len() {
-            (&self, &other)
-        } else {
-            (&other, &self)
-        };
-        let mut new = biggest.clone();
-        for i in 0..smallest.len() {
-            if let Ok(true) = smallest.get(i) {
-                new.set(i, true);
-            }
-        }
-        new
-    }
-}
-
-impl ssz::Encodable for BooleanBitfield {
-    // ssz_append encodes Self according to the `ssz` spec.
-    fn ssz_append(&self, s: &mut ssz::SszStream) {
-        s.append_vec(&self.to_bytes())
-    }
-}
-
-impl ssz::Decodable for BooleanBitfield {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), ssz::DecodeError> {
-        let len = ssz::decode::decode_length(bytes, index, ssz::LENGTH_BYTES)?;
-        if (ssz::LENGTH_BYTES + len) > bytes.len() {
-            return Err(ssz::DecodeError::TooShort);
-        }
-
-        if len == 0 {
-            Ok((BooleanBitfield::new(), index + ssz::LENGTH_BYTES))
-        } else {
-            let bytes = &bytes[(index + 4)..(index + len + 4)];
-
-            let count = len * 8;
-            let mut field = BooleanBitfield::with_capacity(count);
-            for (byte_index, byte) in bytes.iter().enumerate() {
-                for i in 0..8 {
-                    let bit = byte & (128 >> i);
-                    if bit != 0 {
-                        field.set(8 * byte_index + i, true);
-                    }
-                }
-            }
-
-            let index = index + ssz::LENGTH_BYTES + len;
-            Ok((field, index))
-        }
-    }
-}
-
-impl Serialize for BooleanBitfield {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(&ssz::ssz_encode(self))
-    }
-}
-
-impl ssz::TreeHash for BooleanBitfield {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        self.to_bytes().hash_tree_root()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ssz::{ssz_encode, Decodable, SszStream};
-
-    #[test]
-    fn test_new_bitfield() {
-        let mut field = BooleanBitfield::new();
-        let original_len = field.len();
-
-        for i in 0..100 {
-            if i < original_len {
-                assert!(!field.get(i).unwrap());
-            } else {
-                assert!(field.get(i).is_err());
-            }
-            let previous = field.set(i, true);
-            if i < original_len {
-                assert!(!previous.unwrap());
-            } else {
-                assert!(previous.is_none());
-            }
-        }
-    }
-
-    #[test]
-    fn test_empty_bitfield() {
-        let mut field = BooleanBitfield::from_elem(0, false);
-        let original_len = field.len();
-
-        assert_eq!(original_len, 0);
-
-        for i in 0..100 {
-            if i < original_len {
-                assert!(!field.get(i).unwrap());
-            } else {
-                assert!(field.get(i).is_err());
-            }
-            let previous = field.set(i, true);
-            if i < original_len {
-                assert!(!previous.unwrap());
-            } else {
-                assert!(previous.is_none());
-            }
-        }
-
-        assert_eq!(field.len(), 100);
-        assert_eq!(field.num_set_bits(), 100);
-    }
-
-    const INPUT: &[u8] = &[0b0000_0010, 0b0000_0010];
-
-    #[test]
-    fn test_get_from_bitfield() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        let unset = field.get(0).unwrap();
-        assert!(!unset);
-        let set = field.get(6).unwrap();
-        assert!(set);
-        let set = field.get(14).unwrap();
-        assert!(set);
-    }
-
-    #[test]
-    fn test_set_for_bitfield() {
-        let mut field = BooleanBitfield::from_bytes(INPUT);
-        let previous = field.set(10, true).unwrap();
-        assert!(!previous);
-        let previous = field.get(10).unwrap();
-        assert!(previous);
-        let previous = field.set(6, false).unwrap();
-        assert!(previous);
-        let previous = field.get(6).unwrap();
-        assert!(!previous);
-    }
-
-    #[test]
-    fn test_highest_set_bit() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        assert_eq!(field.highest_set_bit().unwrap(), 14);
-
-        let field = BooleanBitfield::from_bytes(&[0b0000_0011]);
-        assert_eq!(field.highest_set_bit().unwrap(), 7);
-
-        let field = BooleanBitfield::new();
-        assert_eq!(field.highest_set_bit(), None);
-    }
-
-    #[test]
-    fn test_len() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        assert_eq!(field.len(), 16);
-
-        let field = BooleanBitfield::new();
-        assert_eq!(field.len(), 8);
-    }
-
-    #[test]
-    fn test_num_set_bits() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        assert_eq!(field.num_set_bits(), 2);
-
-        let field = BooleanBitfield::new();
-        assert_eq!(field.num_set_bits(), 0);
-    }
-
-    #[test]
-    fn test_to_bytes() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        assert_eq!(field.to_bytes(), INPUT);
-
-        let field = BooleanBitfield::new();
-        assert_eq!(field.to_bytes(), vec![0]);
-    }
-
-    #[test]
-    fn test_out_of_bounds() {
-        let mut field = BooleanBitfield::from_bytes(INPUT);
-
-        let out_of_bounds_index = field.len();
-        assert!(field.set(out_of_bounds_index, true).is_none());
-        assert!(field.len() == out_of_bounds_index + 1);
-        assert!(field.get(out_of_bounds_index).unwrap());
-
-        for i in 0..100 {
-            if i <= out_of_bounds_index {
-                assert!(field.set(i, true).is_some());
-            } else {
-                assert!(field.set(i, true).is_none());
-            }
-        }
-    }
-
-    #[test]
-    fn test_grows_with_false() {
-        let input_all_set: &[u8] = &[0b1111_1111, 0b1111_1111];
-        let mut field = BooleanBitfield::from_bytes(input_all_set);
-
-        // Define `a` and `b`, where both are out of bounds and `b` is greater than `a`.
-        let a = field.len();
-        let b = a + 1;
-
-        // Ensure `a` is out-of-bounds for test integrity.
-        assert!(field.get(a).is_err());
-
-        // Set `b` to `true`. Also, for test integrity, ensure it was previously out-of-bounds.
-        assert!(field.set(b, true).is_none());
-
-        // Ensure that `a` wasn't also set to `true` during the grow.
-        assert_eq!(field.get(a), Ok(false));
-        assert_eq!(field.get(b), Ok(true));
-    }
-
-    #[test]
-    fn test_num_bytes() {
-        let field = BooleanBitfield::from_bytes(INPUT);
-        assert_eq!(field.num_bytes(), 2);
-
-        let field = BooleanBitfield::from_elem(2, true);
-        assert_eq!(field.num_bytes(), 1);
-
-        let field = BooleanBitfield::from_elem(13, true);
-        assert_eq!(field.num_bytes(), 2);
-    }
-
-    #[test]
-    fn test_ssz_encode() {
-        let field = create_test_bitfield();
-
-        let mut stream = SszStream::new();
-        stream.append(&field);
-        assert_eq!(stream.drain(), vec![0, 0, 0, 2, 225, 192]);
-
-        let field = BooleanBitfield::from_elem(18, true);
-        let mut stream = SszStream::new();
-        stream.append(&field);
-        assert_eq!(stream.drain(), vec![0, 0, 0, 3, 255, 255, 192]);
-    }
-
-    fn create_test_bitfield() -> BooleanBitfield {
-        let count = 2 * 8;
-        let mut field = BooleanBitfield::with_capacity(count);
-
-        let indices = &[0, 1, 2, 7, 8, 9];
-        for &i in indices {
-            field.set(i, true);
-        }
-        field
-    }
-
-    #[test]
-    fn test_ssz_decode() {
-        let encoded = vec![0, 0, 0, 2, 225, 192];
-        let (field, _): (BooleanBitfield, usize) = ssz::decode_ssz(&encoded, 0).unwrap();
-        let expected = create_test_bitfield();
-        assert_eq!(field, expected);
-
-        let encoded = vec![0, 0, 0, 3, 255, 255, 3];
-        let (field, _): (BooleanBitfield, usize) = ssz::decode_ssz(&encoded, 0).unwrap();
-        let expected = BooleanBitfield::from_bytes(&[255, 255, 3]);
-        assert_eq!(field, expected);
-    }
-
-    #[test]
-    fn test_ssz_round_trip() {
-        let original = BooleanBitfield::from_bytes(&vec![18; 12][..]);
-        let ssz = ssz_encode(&original);
-        let (decoded, _) = BooleanBitfield::ssz_decode(&ssz, 0).unwrap();
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    fn test_bitand() {
-        let a = BooleanBitfield::from_bytes(&vec![2, 8, 1][..]);
-        let b = BooleanBitfield::from_bytes(&vec![4, 8, 16][..]);
-        let c = BooleanBitfield::from_bytes(&vec![6, 8, 17][..]);
-        assert_eq!(c, a & b);
-    }
-}

eth2/utils/hashing/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "hashing"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-tiny-keccak = "1.4.2"

eth2/utils/hashing/src/lib.rs

@@ -1,28 +0,0 @@
-use tiny_keccak::Keccak;
-
-pub fn hash(input: &[u8]) -> Vec<u8> {
-    let mut keccak = Keccak::new_keccak256();
-    keccak.update(input);
-    let mut result = vec![0; 32];
-    keccak.finalize(result.as_mut_slice());
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::convert::From;
-
-    #[test]
-    fn test_hashing() {
-        let input: Vec<u8> = From::from("hello");
-
-        let output = hash(input.as_ref());
-        let expected = &[
-            0x1c, 0x8a, 0xff, 0x95, 0x06, 0x85, 0xc2, 0xed, 0x4b, 0xc3, 0x17, 0x4f, 0x34, 0x72,
-            0x28, 0x7b, 0x56, 0xd9, 0x51, 0x7b, 0x9c, 0x94, 0x81, 0x27, 0x31, 0x9a, 0x09, 0xa7,
-            0xa3, 0x6d, 0xea, 0xc8,
-        ];
-        assert_eq!(expected, output.as_slice());
-    }
-}

eth2/utils/honey-badger-split/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "honey-badger-split"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]

eth2/utils/honey-badger-split/src/lib.rs

@@ -1,85 +0,0 @@
-/// A function for splitting a list into N pieces.
-///
-/// We have titled it the "honey badger split" because of its robustness. It don't care.
-
-/// Iterator for the honey_badger_split function
-pub struct Split<'a, T: 'a> {
-    n: usize,
-    current_pos: usize,
-    list: &'a [T],
-    list_length: usize,
-}
-
-impl<'a, T> Iterator for Split<'a, T> {
-    type Item = &'a [T];
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.current_pos += 1;
-        if self.current_pos <= self.n {
-            match self.list.get(
-                self.list_length * (self.current_pos - 1) / self.n
-                    ..self.list_length * self.current_pos / self.n,
-            ) {
-                Some(v) => Some(v),
-                None => unreachable!(),
-            }
-        } else {
-            None
-        }
-    }
-}
-
-/// Splits a slice into chunks of size n. All postive n values are applicable,
-/// hence the honey_badger prefix.
-///
-/// Returns an iterator over the original list.
-pub trait SplitExt<T> {
-    fn honey_badger_split(&self, n: usize) -> Split<T>;
-}
-
-impl<T> SplitExt<T> for [T] {
-    fn honey_badger_split(&self, n: usize) -> Split<T> {
-        Split {
-            n,
-            current_pos: 0,
-            list: &self,
-            list_length: self.len(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_honey_badger_split() {
-        /*
-         * These test cases are generated from the eth2.0 spec `split()`
-         * function at commit cbd254a.
-         */
-        let input: Vec<usize> = vec![0, 1, 2, 3];
-        let output: Vec<&[usize]> = input.honey_badger_split(2).collect();
-        assert_eq!(output, vec![&[0, 1], &[2, 3]]);
-
-        let input: Vec<usize> = vec![0, 1, 2, 3];
-        let output: Vec<&[usize]> = input.honey_badger_split(6).collect();
-        let expected: Vec<&[usize]> = vec![&[], &[0], &[1], &[], &[2], &[3]];
-        assert_eq!(output, expected);
-
-        let input: Vec<usize> = vec![0, 1, 2, 3];
-        let output: Vec<&[usize]> = input.honey_badger_split(10).collect();
-        let expected: Vec<&[usize]> = vec![&[], &[], &[0], &[], &[1], &[], &[], &[2], &[], &[3]];
-        assert_eq!(output, expected);
-
-        let input: Vec<usize> = vec![0];
-        let output: Vec<&[usize]> = input.honey_badger_split(5).collect();
-        let expected: Vec<&[usize]> = vec![&[], &[], &[], &[], &[0]];
-        assert_eq!(output, expected);
-
-        let input: Vec<usize> = vec![0, 1, 2];
-        let output: Vec<&[usize]> = input.honey_badger_split(2).collect();
-        let expected: Vec<&[usize]> = vec![&[0], &[1, 2]];
-        assert_eq!(output, expected);
-    }
-}

eth2/utils/slot_clock/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "slot_clock"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-types = { path = "../../types" }

eth2/utils/slot_clock/src/lib.rs

@@ -1,12 +0,0 @@
-mod system_time_slot_clock;
-mod testing_slot_clock;
-
-pub use crate::system_time_slot_clock::{Error as SystemTimeSlotClockError, SystemTimeSlotClock};
-pub use crate::testing_slot_clock::{Error as TestingSlotClockError, TestingSlotClock};
-pub use types::Slot;
-
-pub trait SlotClock: Send + Sync {
-    type Error;
-
-    fn present_slot(&self) -> Result<Option<Slot>, Self::Error>;
-}

eth2/utils/slot_clock/src/system_time_slot_clock.rs

@@ -1,139 +0,0 @@
-use super::SlotClock;
-use std::time::{Duration, SystemTime};
-use types::Slot;
-
-pub use std::time::SystemTimeError;
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    SlotDurationIsZero,
-    SystemTimeError(String),
-}
-
-/// Determines the present slot based upon the present system time.
-#[derive(Clone)]
-pub struct SystemTimeSlotClock {
-    genesis_seconds: u64,
-    slot_duration_seconds: u64,
-}
-
-impl SystemTimeSlotClock {
-    /// Create a new `SystemTimeSlotClock`.
-    ///
-    /// Returns an Error if `slot_duration_seconds == 0`.
-    pub fn new(
-        genesis_seconds: u64,
-        slot_duration_seconds: u64,
-    ) -> Result<SystemTimeSlotClock, Error> {
-        if slot_duration_seconds == 0 {
-            Err(Error::SlotDurationIsZero)
-        } else {
-            Ok(Self {
-                genesis_seconds,
-                slot_duration_seconds,
-            })
-        }
-    }
-}
-
-impl SlotClock for SystemTimeSlotClock {
-    type Error = Error;
-
-    fn present_slot(&self) -> Result<Option<Slot>, Error> {
-        let syslot_time = SystemTime::now();
-        let duration_since_epoch = syslot_time.duration_since(SystemTime::UNIX_EPOCH)?;
-        let duration_since_genesis =
-            duration_since_epoch.checked_sub(Duration::from_secs(self.genesis_seconds));
-        match duration_since_genesis {
-            None => Ok(None),
-            Some(d) => Ok(slot_from_duration(self.slot_duration_seconds, d)),
-        }
-    }
-}
-
-impl From<SystemTimeError> for Error {
-    fn from(e: SystemTimeError) -> Error {
-        Error::SystemTimeError(format!("{:?}", e))
-    }
-}
-
-fn slot_from_duration(slot_duration_seconds: u64, duration: Duration) -> Option<Slot> {
-    Some(Slot::new(
-        duration.as_secs().checked_div(slot_duration_seconds)?,
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /*
-     * Note: these tests are using actual system times and could fail if they are executed on a
-     * very slow machine.
-     */
-    #[test]
-    fn test_slot_now() {
-        let slot_time = 100;
-
-        let now = SystemTime::now();
-        let since_epoch = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
-
-        let genesis = since_epoch.as_secs() - slot_time * 89;
-
-        let clock = SystemTimeSlotClock {
-            genesis_seconds: genesis,
-            slot_duration_seconds: slot_time,
-        };
-        assert_eq!(clock.present_slot().unwrap(), Some(Slot::new(89)));
-
-        let clock = SystemTimeSlotClock {
-            genesis_seconds: since_epoch.as_secs(),
-            slot_duration_seconds: slot_time,
-        };
-        assert_eq!(clock.present_slot().unwrap(), Some(Slot::new(0)));
-
-        let clock = SystemTimeSlotClock {
-            genesis_seconds: since_epoch.as_secs() - slot_time * 42 - 5,
-            slot_duration_seconds: slot_time,
-        };
-        assert_eq!(clock.present_slot().unwrap(), Some(Slot::new(42)));
-    }
-
-    #[test]
-    fn test_slot_from_duration() {
-        let slot_time = 100;
-
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(0)),
-            Some(Slot::new(0))
-        );
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(10)),
-            Some(Slot::new(0))
-        );
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(100)),
-            Some(Slot::new(1))
-        );
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(101)),
-            Some(Slot::new(1))
-        );
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(1000)),
-            Some(Slot::new(10))
-        );
-    }
-
-    #[test]
-    fn test_slot_from_duration_slot_time_zero() {
-        let slot_time = 0;
-
-        assert_eq!(slot_from_duration(slot_time, Duration::from_secs(0)), None);
-        assert_eq!(slot_from_duration(slot_time, Duration::from_secs(10)), None);
-        assert_eq!(
-            slot_from_duration(slot_time, Duration::from_secs(1000)),
-            None
-        );
-    }
-}

eth2/utils/slot_clock/src/testing_slot_clock.rs

@@ -1,48 +0,0 @@
-use super::SlotClock;
-use std::sync::RwLock;
-use types::Slot;
-
-#[derive(Debug, PartialEq)]
-pub enum Error {}
-
-/// Determines the present slot based upon the present system time.
-pub struct TestingSlotClock {
-    slot: RwLock<u64>,
-}
-
-impl TestingSlotClock {
-    /// Create a new `TestingSlotClock`.
-    ///
-    /// Returns an Error if `slot_duration_seconds == 0`.
-    pub fn new(slot: u64) -> TestingSlotClock {
-        TestingSlotClock {
-            slot: RwLock::new(slot),
-        }
-    }
-
-    pub fn set_slot(&self, slot: u64) {
-        *self.slot.write().expect("TestingSlotClock poisoned.") = slot;
-    }
-}
-
-impl SlotClock for TestingSlotClock {
-    type Error = Error;
-
-    fn present_slot(&self) -> Result<Option<Slot>, Error> {
-        let slot = *self.slot.read().expect("TestingSlotClock poisoned.");
-        Ok(Some(Slot::new(slot)))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_slot_now() {
-        let clock = TestingSlotClock::new(10);
-        assert_eq!(clock.present_slot(), Ok(Some(Slot::new(10))));
-        clock.set_slot(123);
-        assert_eq!(clock.present_slot(), Ok(Some(Slot::new(123))));
-    }
-}

eth2/utils/ssz/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "ssz"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-bytes = "0.4.9"
-ethereum-types = "0.4.0"
-hashing = { path = "../hashing" }

eth2/utils/ssz/README.md

@@ -1,543 +0,0 @@
-# simpleserialize (ssz) [WIP]
-
-This is currently a ***Work In Progress*** crate.
-
-SimpleSerialize is a serialization protocol described by Vitalik Buterin. The
-method is tentatively intended for use in the Ethereum Beacon Chain as
-described in the [Ethereum 2.1 Spec](https://notes.ethereum.org/s/Syj3QZSxm).
-The Beacon Chain specification is the core, canonical specification which we
-are following.
-
-The current reference implementation has been described in the [Beacon Chain
-Repository](https://github.com/ethereum/beacon_chain/blob/master/ssz/ssz.py).
-
-*Please Note: This implementation is presently a placeholder until the final
-spec is decided.*\
-*Do not rely upon it for reference.*
-
-
-## Table of Contents
-
-* [SimpleSerialize Overview](#simpleserialize-overview)
-  + [Serialize/Encode](#serializeencode)
-    - [int or uint: 8/16/24/32/64/256](#int-or-uint-816243264256)
-    - [Address](#address)
-    - [Hash32](#hash32)
-    - [Bytes](#bytes)
-    - [List](#list)
-  + [Deserialize/Decode](#deserializedecode)
-    - [Int or Uint: 8/16/24/32/64/256](#int-or-uint-816243264256)
-    - [Address](#address-1)
-    - [Hash32](#hash32-1)
-    - [Bytes](#bytes-1)
-    - [List](#list-1)
-* [Technical Overview](#technical-overview)
-* [Building](#building)
-  + [Installing Rust](#installing-rust)
-* [Dependencies](#dependencies)
-  + [bytes v0.4.9](#bytes-v049)
-  + [ethereum-types](#ethereum-types)
-* [Interface](#interface)
-  + [Encodable](#encodable)
-  + [Decodable](#decodable)
-  + [SszStream](#sszstream)
-    - [new()](#new)
-    - [append(&mut self, value: &E) -> &mut Self](#appendmut-self-value-e---mut-self)
-    - [append_encoded_val(&mut self, vec: &Vec)](#append_encoded_valmut-self-vec-vec)
-    - [append_vec(&mut self, vec: &Vec)](#append_vecmut-self-vec-vec)
-    - [drain(self) -> Vec](#drainself---vec)
-  + [decode_ssz(ssz_bytes: &(u8), index: usize) -> Result](#decode_sszssz_bytes-u8-index-usize---resultt-usize-decodeerror)
-  + [decode_ssz_list(ssz_bytes: &(u8), index: usize) -> Result, usize), DecodeError>](#decode_ssz_listssz_bytes-u8-index-usize---resultvec-usize-decodeerror)
-  + [decode_length(bytes: &(u8), index: usize, length_bytes: usize) -> Result](#decode_lengthbytes-u8-index-usize-length_bytes-usize---resultusize-decodeerror)
-* [Usage](#usage)
-  + [Serializing/Encoding](#serializingencoding)
-    - [Rust](#rust)
-* [Deserializing/Decoding](#deserializingdecoding)
-    - [Rust](#rust-1)
-
----
-
-## SimpleSerialize Overview
-
-The ``simpleserialize`` method for serialization follows simple byte conversion,
-making it effective and efficient for encoding and decoding.
-
-The decoding requires knowledge of the data **type** and the order of the
-serialization.
-
-Syntax:
-
-| Shorthand    | Meaning                                             |
-|:-------------|:----------------------------------------------------|
-| `big`        | ``big endian``                                      |
-| `to_bytes`   | convert to bytes. Params: ``(size, byte order)``    |
-| `from_bytes` | convert from bytes. Params: ``(bytes, byte order)`` |
-| `value`      | the value to serialize                              |
-| `rawbytes`   | raw encoded/serialized bytes                        |
-| `len(value)` | get the length of the value. (number of bytes etc)  |
-
-### Serialize/Encode
-
-#### int or uint: 8/16/24/32/64/256
-
-Convert directly to bytes the size of the int. (e.g. ``int16 = 2 bytes``)
-
-All integers are serialized as **big endian**.
-
-| Check to perform       | Code                    |
-|:-----------------------|:------------------------|
-| Int size is not 0      | ``int_size > 0``        |
-| Size is a byte integer | ``int_size % 8 == 0``   |
-| Value is less than max | ``2**int_size > value`` |
-
-```python
-buffer_size = int_size / 8
-return value.to_bytes(buffer_size, 'big')
-```
-
-#### Address
-
-The address should already come as a hash/byte format. Ensure that length is
-**20**.
-
-| Check to perform       | Code                 |
-|:-----------------------|:---------------------|
-| Length is correct (20) | ``len(value) == 20`` |
-
-```python
-assert( len(value) == 20 )
-return value
-```
-
-#### Hash32
-
-The hash32 should already be a 32 byte length serialized data format. The safety
-check ensures the 32 byte length is satisfied.
-
-| Check to perform       | Code                 |
-|:-----------------------|:---------------------|
-| Length is correct (32) | ``len(value) == 32`` |
-
-```python
-assert( len(value) == 32 )
-return value
-```
-
-#### Bytes
-
-For general `byte` type:
-1. Get the length/number of bytes; Encode into a 4 byte integer.
-2. Append the value to the length and return: ``[ length_bytes ] + [
-   value_bytes ]``
-
-```python
-byte_length = (len(value)).to_bytes(4, 'big')
-return byte_length + value
-```
-
-#### List
-
-For lists of values, get the length of the list and then serialize the value
-of each item in the list:
-1. For each item in list:
-   1. serialize.
-   2. append to string.
-2. Get size of serialized string. Encode into a 4 byte integer.
-
-```python
-serialized_list_string = ''
-
-for item in value:
-   serialized_list_string += serialize(item)
-
-serialized_len = len(serialized_list_string)
-
-return serialized_len + serialized_list_string
-```
-
-### Deserialize/Decode
-
-The decoding requires knowledge of the type of the item to be decoded. When
-performing decoding on an entire serialized string, it also requires knowledge
-of what order the objects have been serialized in.
-
-Note: Each return will provide ``deserialized_object, new_index`` keeping track
-of the new index.
-
-At each step, the following checks should be made:
-
-| Check Type               | Check                                                     |
-|:-------------------------|:----------------------------------------------------------|
-| Ensure sufficient length | ``length(rawbytes) > current_index + deserialize_length`` |
-
-#### Int or Uint: 8/16/24/32/64/256
-
-Convert directly from bytes into integer utilising the number of bytes the same
-size as the integer length. (e.g. ``int16 == 2 bytes``)
-
-All integers are interpreted as **big endian**.
-
-```python
-byte_length = int_size / 8
-new_index = current_index + int_size
-return int.from_bytes(rawbytes[current_index:current_index+int_size], 'big'), new_index
-```
-
-#### Address
-
-Return the 20 bytes.
-
-```python
-new_index = current_index + 20
-return rawbytes[current_index:current_index+20], new_index
-```
-
-#### Hash32
-
-Return the 32 bytes.
-
-```python
-new_index = current_index + 32
-return rawbytes[current_index:current_index+32], new_index
-```
-
-#### Bytes
-
-Get the length of the bytes, return the bytes.
-
-```python
-bytes_length = int.from_bytes(rawbytes[current_index:current_index+4], 'big')
-new_index = current_index + 4 + bytes_lenth
-return rawbytes[current_index+4:current_index+4+bytes_length], new_index
-```
-
-#### List
-
-Deserailize each object in the list.
-1. Get the length of the serialized list.
-2. Loop through deseralizing each item in the list until you reach the
-entire length of the list.
-
-
-| Check type                          | code                                  |
-|:------------------------------------|:--------------------------------------|
-| rawbytes has enough left for length | ``len(rawbytes) > current_index + 4`` |
-
-```python
-total_length = int.from_bytes(rawbytes[current_index:current_index+4], 'big')
-new_index = current_index + 4 + total_length
-item_index = current_index + 4
-deserialized_list = []
-
-while item_index < new_index:
-   object, item_index = deserialize(rawbytes, item_index, item_type)
-   deserialized_list.append(object)
-
-return deserialized_list, new_index
-```
-
-## Technical Overview
-
-The SimpleSerialize is a simple method for serializing objects for use in the
-Ethereum beacon chain proposed by Vitalik Buterin. There are currently two
-implementations denoting the functionality, the [Reference
-Implementation](https://github.com/ethereum/beacon_chain/blob/master/ssz/ssz.py)
-and the [Module](https://github.com/ethereum/research/tree/master/py_ssz) in
-Ethereum research. It is being developed as a crate for the [**Rust programming
-language**](https://www.rust-lang.org).
-
-The crate will provide the functionality to serialize several types in
-accordance with the spec and provide a serialized stream of bytes.
-
-## Building
-
-ssz currently builds on **rust v1.27.1**
-
-### Installing Rust
-
-The [**Rustup**](https://rustup.rs/) tool provides functionality to easily
-manage rust on your local instance. It is a recommended method for installing
-rust.
-
-Installing on Linux or OSX:
-
-```bash
-curl https://sh.rustup.rs -sSf | sh
-```
-
-Installing on Windows:
-
-* 32 Bit: [ https://win.rustup.rs/i686 ](https://win.rustup.rs/i686)
-* 64 Bit: [ https://win.rustup.rs/x86_64 ](https://win.rustup.rs/x86_64)
-
-## Dependencies
-
-All dependencies are listed in the ``Cargo.toml`` file.
-
-To build and install all related dependencies:
-
-```bash
-cargo build
-```
-
-### bytes v0.4.9
-
-The `bytes` crate provides effective Byte Buffer implementations and
-interfaces.
-
-Documentation: [ https://docs.rs/bytes/0.4.9/bytes/ ](https://docs.rs/bytes/0.4.9/bytes/)
-
-### ethereum-types
-
-The `ethereum-types` provide primitives for types that are commonly used in the
-ethereum protocol. This crate is provided by [Parity](https://www.parity.io/).
-
-Github: [ https://github.com/paritytech/primitives ](https://github.com/paritytech/primitives)
-
-
----
-
-## Interface
-
-### Encodable
-
-A type is **Encodable** if it has a valid ``ssz_append`` function. This is
-used to ensure that the object/type can be serialized.
-
-```rust
-pub trait Encodable {
-    fn ssz_append(&self, s: &mut SszStream);
-}
-```
-
-### Decodable
-
-A type is **Decodable** if it has a valid ``ssz_decode`` function. This is
-used to ensure the object is deserializable.
-
-```rust
-pub trait Decodable: Sized {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError>;
-}
-```
-
-### SszStream
-
-The main implementation is the `SszStream` struct. The struct contains a
-buffer of bytes, a Vector of `uint8`.
-
-#### new()
-
-Create a new, empty instance of the SszStream.
-
-**Example**
-
-```rust
-let mut ssz = SszStream::new()
-```
-
-#### append<E>(&mut self, value: &E) -> &mut Self
-
-Appends a value that can be encoded into the stream.
-
-| Parameter | Description                              |
-|:---------:|:-----------------------------------------|
-| ``value`` | Encodable value to append to the stream. |
-
-**Example**
-
-```rust
-ssz.append(&x)
-```
-
-#### append_encoded_val(&mut self, vec: &Vec<u8>)
-
-Appends some ssz encoded bytes to the stream.
-
-| Parameter | Description                       |
-|:---------:|:----------------------------------|
-|  ``vec``  | A vector of serialized ssz bytes. |
-
-**Example**
-
-```rust
-let mut a = [0, 1];
-ssz.append_encoded_val(&a.to_vec());
-```
-
-#### append_vec<E>(&mut self, vec: &Vec<E>)
-
-Appends some vector (list) of encodable values to the stream.
-
-| Parameter | Description                                   |
-|:---------:|:----------------------------------------------|
-|  ``vec``  | Vector of Encodable objects to be serialized. |
-
-**Example**
-
-```rust
-ssz.append_vec(attestations);
-```
-
-#### drain(self) -> Vec<u8>
-
-Consumes the ssz stream and returns the buffer of bytes.
-
-**Example**
-
-```rust
-ssz.drain()
-```
-
-### decode_ssz<T>(ssz_bytes: &[u8], index: usize) -> Result<(T, usize), DecodeError>
-
-Decodes a single ssz serialized value of type `T`. Note: `T` must be decodable.
-
-|   Parameter   | Description                         |
-|:-------------:|:------------------------------------|
-| ``ssz_bytes`` | Serialized list of bytes.           |
-|   ``index``   | Starting index to deserialize from. |
-
-**Returns**
-
-|     Return Value    | Description                                   |
-|:-------------------:|:----------------------------------------------|
-| ``Tuple(T, usize)`` | Returns the tuple of the type and next index. |
-|   ``DecodeError``   | Error if the decoding could not be performed. |
-
-**Example**
-
-```rust
-let res: Result<(u16, usize), DecodeError> = decode_ssz(&encoded_ssz, 0);
-```
-
-### decode_ssz_list<T>(ssz_bytes: &[u8], index: usize) -> Result<(Vec<T>, usize), DecodeError>
-
-Decodes a list of serialized values into a vector.
-
-|   Parameter   | Description                         |
-|:-------------:|:------------------------------------|
-| ``ssz_bytes`` | Serialized list of bytes.           |
-|   ``index``   | Starting index to deserialize from. |
-
-**Returns**
-
-|       Return Value       | Description                                   |
-|:------------------------:|:----------------------------------------------|
-| ``Tuple(Vec<T>, usize)`` | Returns the tuple of the type and next index. |
-|      ``DecodeError``     | Error if the decoding could not be performed. |
-
-**Example**
-
-```rust
-let decoded: Result<(Vec<usize>, usize), DecodeError> = decode_ssz_list( &encoded_ssz, 0);
-```
-
-### decode_length(bytes: &[u8], index: usize, length_bytes: usize) -> Result<usize, DecodeError>
-
-Deserializes the "length" value in the serialized bytes from the index. The
-length of bytes is given (usually 4 stated in the reference implementation) and
-is often the value appended to the list infront of the actual serialized
-object.
-
-|     Parameter    | Description                                |
-|:----------------:|:-------------------------------------------|
-|     ``bytes``    | Serialized list of bytes.                  |
-|     ``index``    | Starting index to deserialize from.        |
-| ``length_bytes`` | Number of bytes to deserialize into usize. |
-
-
-**Returns**
-
-|   Return Value  | Description                                                |
-|:---------------:|:-----------------------------------------------------------|
-|    ``usize``    | The length of the serialized object following this length. |
-| ``DecodeError`` | Error if the decoding could not be performed.              |
-
-**Example**
-
-```rust
-let length_of_serialized: Result<usize, DecodeError> = decode_length(&encoded, 0, 4);
-```
-
----
-
-## Usage
-
-### Serializing/Encoding
-
-#### Rust
-
-Create the `simpleserialize` stream that will produce the serialized objects.
-
-```rust
-let mut ssz = SszStream::new();
-```
-
-Encode the values that you need by using the ``append(..)`` method on the `SszStream`.
-
-The **append** function is how the value gets serialized.
-
-```rust
-let x: u64 = 1 << 32;
-ssz.append(&x);
-```
-
-To get the serialized byte vector use ``drain()`` on the `SszStream`.
-
-```rust
-ssz.drain()
-```
-
-**Example**
-
-```rust
-// 1 << 32 = 4294967296;
-// As bytes it should equal: [0,0,0,1,0,0,0]
-let x: u64 = 1 << 32;
-
-// Create the new ssz stream
-let mut ssz = SszStream::new();
-
-// Serialize x
-ssz.append(&x);
-
-// Check that it is correct.
-assert_eq!(ssz.drain(), vec![0,0,0,1,0,0,0]);
-```
-
-## Deserializing/Decoding
-
-#### Rust
-
-From the `simpleserialize` bytes, we are converting to the object.
-
-```rust
-let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255];
-
-// Returns the result and the next index to decode.
-let (result, index): (u64, usize) = decode_ssz(&ssz, 3).unwrap();
-
-// Check for correctness
-// 2**64-1 = 18446744073709551615
-assert_eq!(result, 18446744073709551615);
-// Index = 3 (initial index) + 8 (8 byte int) = 11
-assert_eq!(index, 11);
-```
-
-Decoding a list of items:
-
-```rust
-// Encoded/Serialized list with junk numbers at the front
-let serialized_list = vec![ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 32, 0, 0, 0,
-                            0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0,
-                            0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15];
-
-// Returns the result (Vector of usize) and the index of the next
-let decoded: (Vec<usize>, usize) = decode_ssz_list(&serialized_list, 10).unwrap();
-
-// Check for correctness
-assert_eq!(decoded.0, vec![15,15,15,15]);
-
-assert_eq!(decoded.1, 46);
-```

eth2/utils/ssz/src/decode.rs

@@ -1,193 +0,0 @@
-use super::LENGTH_BYTES;
-
-#[derive(Debug, PartialEq)]
-pub enum DecodeError {
-    TooShort,
-    TooLong,
-    Invalid,
-}
-
-pub trait Decodable: Sized {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError>;
-}
-
-/// Decode the given bytes for the given type
-///
-/// The single ssz encoded value will be decoded as the given type at the
-/// given index.
-pub fn decode_ssz<T>(ssz_bytes: &[u8], index: usize) -> Result<(T, usize), DecodeError>
-where
-    T: Decodable,
-{
-    if index >= ssz_bytes.len() {
-        return Err(DecodeError::TooShort);
-    }
-    T::ssz_decode(ssz_bytes, index)
-}
-
-/// Decode a vector (list) of encoded bytes.
-///
-/// Each element in the list will be decoded and placed into the vector.
-pub fn decode_ssz_list<T>(ssz_bytes: &[u8], index: usize) -> Result<(Vec<T>, usize), DecodeError>
-where
-    T: Decodable,
-{
-    if index + LENGTH_BYTES > ssz_bytes.len() {
-        return Err(DecodeError::TooShort);
-    };
-
-    // get the length
-    let serialized_length = match decode_length(ssz_bytes, index, LENGTH_BYTES) {
-        Err(v) => return Err(v),
-        Ok(v) => v,
-    };
-
-    let final_len: usize = index + LENGTH_BYTES + serialized_length;
-
-    if final_len > ssz_bytes.len() {
-        return Err(DecodeError::TooShort);
-    };
-
-    let mut tmp_index = index + LENGTH_BYTES;
-    let mut res_vec: Vec<T> = Vec::new();
-
-    while tmp_index < final_len {
-        match T::ssz_decode(ssz_bytes, tmp_index) {
-            Err(v) => return Err(v),
-            Ok(v) => {
-                tmp_index = v.1;
-                res_vec.push(v.0);
-            }
-        };
-    }
-
-    Ok((res_vec, final_len))
-}
-
-/// Given some number of bytes, interpret the first four
-/// bytes as a 32-bit big-endian integer and return the
-/// result.
-pub fn decode_length(
-    bytes: &[u8],
-    index: usize,
-    length_bytes: usize,
-) -> Result<usize, DecodeError> {
-    if bytes.len() < index + length_bytes {
-        return Err(DecodeError::TooShort);
-    };
-    let mut len: usize = 0;
-    for (i, byte) in bytes
-        .iter()
-        .enumerate()
-        .take(index + length_bytes)
-        .skip(index)
-    {
-        let offset = (index + length_bytes - i - 1) * 8;
-        len |= (*byte as usize) << offset;
-    }
-    Ok(len)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::encode::encode_length;
-    use super::*;
-
-    #[test]
-    fn test_ssz_decode_length() {
-        let decoded = decode_length(&vec![0, 0, 0, 1], 0, LENGTH_BYTES);
-        assert_eq!(decoded.unwrap(), 1);
-
-        let decoded = decode_length(&vec![0, 0, 1, 0], 0, LENGTH_BYTES);
-        assert_eq!(decoded.unwrap(), 256);
-
-        let decoded = decode_length(&vec![0, 0, 1, 255], 0, LENGTH_BYTES);
-        assert_eq!(decoded.unwrap(), 511);
-
-        let decoded = decode_length(&vec![255, 255, 255, 255], 0, LENGTH_BYTES);
-        assert_eq!(decoded.unwrap(), 4294967295);
-    }
-
-    #[test]
-    fn test_encode_decode_length() {
-        let params: Vec<usize> = vec![
-            0,
-            1,
-            2,
-            3,
-            7,
-            8,
-            16,
-            2 ^ 8,
-            2 ^ 8 + 1,
-            2 ^ 16,
-            2 ^ 16 + 1,
-            2 ^ 24,
-            2 ^ 24 + 1,
-            2 ^ 32,
-        ];
-        for i in params {
-            let decoded = decode_length(&encode_length(i, LENGTH_BYTES), 0, LENGTH_BYTES).unwrap();
-            assert_eq!(i, decoded);
-        }
-    }
-
-    #[test]
-    fn test_decode_ssz_list() {
-        // u16
-        let v: Vec<u16> = vec![10, 10, 10, 10];
-        let decoded: (Vec<u16>, usize) =
-            decode_ssz_list(&vec![0, 0, 0, 8, 0, 10, 0, 10, 0, 10, 0, 10], 0).unwrap();
-
-        assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 12);
-
-        // u32
-        let v: Vec<u32> = vec![10, 10, 10, 10];
-        let decoded: (Vec<u32>, usize) = decode_ssz_list(
-            &vec![
-                0, 0, 0, 16, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10,
-            ],
-            0,
-        )
-        .unwrap();
-        assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 20);
-
-        // u64
-        let v: Vec<u64> = vec![10, 10, 10, 10];
-        let decoded: (Vec<u64>, usize) = decode_ssz_list(
-            &vec![
-                0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0,
-                10, 0, 0, 0, 0, 0, 0, 0, 10,
-            ],
-            0,
-        )
-        .unwrap();
-        assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 36);
-
-        // Check that it can accept index
-        let v: Vec<usize> = vec![15, 15, 15, 15];
-        let decoded: (Vec<usize>, usize) = decode_ssz_list(
-            &vec![
-                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0,
-                0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15,
-            ],
-            10,
-        )
-        .unwrap();
-        assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 46);
-
-        // Check that length > bytes throws error
-        let decoded: Result<(Vec<usize>, usize), DecodeError> =
-            decode_ssz_list(&vec![0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 15], 0);
-        assert_eq!(decoded, Err(DecodeError::TooShort));
-
-        // Check that incorrect index throws error
-        let decoded: Result<(Vec<usize>, usize), DecodeError> =
-            decode_ssz_list(&vec![0, 0, 0, 0, 0, 0, 0, 15], 16);
-        assert_eq!(decoded, Err(DecodeError::TooShort));
-    }
-}

eth2/utils/ssz/src/encode.rs

@@ -1,124 +0,0 @@
-use super::LENGTH_BYTES;
-
-pub trait Encodable {
-    fn ssz_append(&self, s: &mut SszStream);
-}
-
-/// Provides a buffer for appending ssz-encodable values.
-///
-/// Use the `append()` fn to add a value to a list, then use
-/// the `drain()` method to consume the struct and return the
-/// ssz encoded bytes.
-#[derive(Default)]
-pub struct SszStream {
-    buffer: Vec<u8>,
-}
-
-impl SszStream {
-    /// Create a new, empty stream for writing ssz values.
-    pub fn new() -> Self {
-        SszStream { buffer: Vec::new() }
-    }
-
-    /// Append some ssz encodable value to the stream.
-    pub fn append<E>(&mut self, value: &E) -> &mut Self
-    where
-        E: Encodable,
-    {
-        value.ssz_append(self);
-        self
-    }
-
-    /// Append some ssz encoded bytes to the stream.
-    ///
-    /// The length of the supplied bytes will be concatenated
-    /// to the stream before the supplied bytes.
-    pub fn append_encoded_val(&mut self, vec: &[u8]) {
-        self.buffer
-            .extend_from_slice(&encode_length(vec.len(), LENGTH_BYTES));
-        self.buffer.extend_from_slice(&vec);
-    }
-
-    /// Append some ssz encoded bytes to the stream without calculating length
-    ///
-    /// The raw bytes will be concatenated to the stream.
-    pub fn append_encoded_raw(&mut self, vec: &[u8]) {
-        self.buffer.extend_from_slice(&vec);
-    }
-
-    /// Append some vector (list) of encodable values to the stream.
-    ///
-    /// The length of the list will be concatenated to the stream, then
-    /// each item in the vector will be encoded and concatenated.
-    pub fn append_vec<E>(&mut self, vec: &[E])
-    where
-        E: Encodable,
-    {
-        let mut list_stream = SszStream::new();
-        for item in vec {
-            item.ssz_append(&mut list_stream);
-        }
-        self.append_encoded_val(&list_stream.drain());
-    }
-
-    /// Consume the stream and return the underlying bytes.
-    pub fn drain(self) -> Vec<u8> {
-        self.buffer
-    }
-}
-
-/// Encode some length into a ssz size prefix.
-///
-/// The ssz size prefix is 4 bytes, which is treated as a continuious
-/// 32bit big-endian integer.
-pub fn encode_length(len: usize, length_bytes: usize) -> Vec<u8> {
-    assert!(length_bytes > 0); // For sanity
-    assert!((len as usize) < 2usize.pow(length_bytes as u32 * 8));
-    let mut header: Vec<u8> = vec![0; length_bytes];
-    for (i, header_byte) in header.iter_mut().enumerate() {
-        let offset = (length_bytes - i - 1) * 8;
-        *header_byte = ((len >> offset) & 0xff) as u8;
-    }
-    header
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    #[should_panic]
-    fn test_encode_length_0_bytes_panic() {
-        encode_length(0, 0);
-    }
-
-    #[test]
-    fn test_encode_length_4_bytes() {
-        assert_eq!(encode_length(0, LENGTH_BYTES), vec![0; 4]);
-        assert_eq!(encode_length(1, LENGTH_BYTES), vec![0, 0, 0, 1]);
-        assert_eq!(encode_length(255, LENGTH_BYTES), vec![0, 0, 0, 255]);
-        assert_eq!(encode_length(256, LENGTH_BYTES), vec![0, 0, 1, 0]);
-        assert_eq!(
-            encode_length(4294967295, LENGTH_BYTES), // 2^(3*8) - 1
-            vec![255, 255, 255, 255]
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_encode_length_4_bytes_panic() {
-        encode_length(4294967296, LENGTH_BYTES); // 2^(3*8)
-    }
-
-    #[test]
-    fn test_encode_list() {
-        let test_vec: Vec<u16> = vec![256; 12];
-        let mut stream = SszStream::new();
-        stream.append_vec(&test_vec);
-        let ssz = stream.drain();
-
-        assert_eq!(ssz.len(), 4 + (12 * 2));
-        assert_eq!(ssz[0..4], *vec![0, 0, 0, 24]);
-        assert_eq!(ssz[4..6], *vec![1, 0]);
-    }
-}

eth2/utils/ssz/src/impl_decode.rs

@@ -1,218 +0,0 @@
-use super::decode::decode_ssz_list;
-use super::ethereum_types::{Address, H256};
-use super::{Decodable, DecodeError};
-
-macro_rules! impl_decodable_for_uint {
-    ($type: ident, $bit_size: expr) => {
-        impl Decodable for $type {
-            fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
-                assert!((0 < $bit_size) & ($bit_size <= 64) & ($bit_size % 8 == 0));
-                let max_bytes = $bit_size / 8;
-                if bytes.len() >= (index + max_bytes) {
-                    let end_bytes = index + max_bytes;
-                    let mut result: $type = 0;
-                    for (i, byte) in bytes.iter().enumerate().take(end_bytes).skip(index) {
-                        let offset = (end_bytes - i - 1) * 8;
-                        result |= ($type::from(*byte)) << offset;
-                    }
-                    Ok((result, end_bytes))
-                } else {
-                    Err(DecodeError::TooShort)
-                }
-            }
-        }
-    };
-}
-
-impl_decodable_for_uint!(u16, 16);
-impl_decodable_for_uint!(u32, 32);
-impl_decodable_for_uint!(u64, 64);
-impl_decodable_for_uint!(usize, 64);
-
-impl Decodable for u8 {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
-        if index >= bytes.len() {
-            Err(DecodeError::TooShort)
-        } else {
-            Ok((bytes[index], index + 1))
-        }
-    }
-}
-
-impl Decodable for H256 {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
-        if bytes.len() < 32 || bytes.len() - 32 < index {
-            Err(DecodeError::TooShort)
-        } else {
-            Ok((H256::from(&bytes[index..(index + 32)]), index + 32))
-        }
-    }
-}
-
-impl Decodable for Address {
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
-        if bytes.len() < 20 || bytes.len() - 20 < index {
-            Err(DecodeError::TooShort)
-        } else {
-            Ok((Address::from(&bytes[index..(index + 20)]), index + 20))
-        }
-    }
-}
-
-impl<T> Decodable for Vec<T>
-where
-    T: Decodable,
-{
-    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
-        decode_ssz_list(bytes, index)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::{decode_ssz, DecodeError};
-    use super::*;
-
-    #[test]
-    fn test_ssz_decode_h256() {
-        /*
-         * Input is exact length
-         */
-        let input = vec![42_u8; 32];
-        let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
-        assert_eq!(decoded.to_vec(), input);
-        assert_eq!(i, 32);
-
-        /*
-         * Input is too long
-         */
-        let mut input = vec![42_u8; 32];
-        input.push(12);
-        let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
-        assert_eq!(decoded.to_vec()[..], input[0..32]);
-        assert_eq!(i, 32);
-
-        /*
-         * Input is too short
-         */
-        let input = vec![42_u8; 31];
-        let res = H256::ssz_decode(&input, 0);
-        assert_eq!(res, Err(DecodeError::TooShort));
-    }
-
-    #[test]
-    fn test_ssz_decode_u16() {
-        let ssz = vec![0, 0];
-
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(result, 0);
-        assert_eq!(index, 2);
-
-        let ssz = vec![0, 16];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(result, 16);
-        assert_eq!(index, 2);
-
-        let ssz = vec![1, 0];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(result, 256);
-        assert_eq!(index, 2);
-
-        let ssz = vec![255, 255];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 2);
-        assert_eq!(result, 65535);
-
-        let ssz = vec![1];
-        let result: Result<(u16, usize), DecodeError> = decode_ssz(&ssz, 0);
-        assert_eq!(result, Err(DecodeError::TooShort));
-    }
-
-    #[test]
-    fn test_ssz_decode_u32() {
-        let ssz = vec![0, 0, 0, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(result, 0);
-        assert_eq!(index, 4);
-
-        let ssz = vec![0, 0, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 4);
-        assert_eq!(result, 256);
-
-        let ssz = vec![255, 255, 255, 0, 0, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 3).unwrap();
-        assert_eq!(index, 7);
-        assert_eq!(result, 256);
-
-        let ssz = vec![0, 200, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 4);
-        assert_eq!(result, 13107456);
-
-        let ssz = vec![255, 255, 255, 255];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 4);
-        assert_eq!(result, 4294967295);
-
-        let ssz = vec![0, 0, 1];
-        let result: Result<(u32, usize), DecodeError> = decode_ssz(&ssz, 0);
-        assert_eq!(result, Err(DecodeError::TooShort));
-    }
-
-    #[test]
-    fn test_ssz_decode_u64() {
-        let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 8);
-        assert_eq!(result, 0);
-
-        let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 8);
-        assert_eq!(result, 18446744073709551615);
-
-        let ssz = vec![0, 0, 8, 255, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 3).unwrap();
-        assert_eq!(index, 11);
-        assert_eq!(result, 18374686479671623680);
-
-        let ssz = vec![0, 0, 0, 0, 0, 0, 0];
-        let result: Result<(u64, usize), DecodeError> = decode_ssz(&ssz, 0);
-        assert_eq!(result, Err(DecodeError::TooShort));
-    }
-
-    #[test]
-    fn test_ssz_decode_usize() {
-        let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 8);
-        assert_eq!(result, 0);
-
-        let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 3).unwrap();
-        assert_eq!(index, 11);
-        assert_eq!(result, 18446744073709551615);
-
-        let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 8);
-        assert_eq!(result, 18446744073709551615);
-
-        let ssz = vec![0, 0, 0, 0, 0, 0, 1];
-        let result: Result<(usize, usize), DecodeError> = decode_ssz(&ssz, 0);
-        assert_eq!(result, Err(DecodeError::TooShort));
-    }
-
-    #[test]
-    fn test_decode_ssz_bounds() {
-        let err: Result<(u16, usize), DecodeError> = decode_ssz(&vec![1], 2);
-        assert_eq!(err, Err(DecodeError::TooShort));
-
-        let err: Result<(u16, usize), DecodeError> = decode_ssz(&vec![0, 0, 0, 0], 3);
-        assert_eq!(err, Err(DecodeError::TooShort));
-
-        let result: u16 = decode_ssz(&vec![0, 0, 0, 0, 1], 3).unwrap().0;
-        assert_eq!(result, 1);
-    }
-}

eth2/utils/ssz/src/impl_encode.rs

@@ -1,209 +0,0 @@
-extern crate bytes;
-
-use self::bytes::{BufMut, BytesMut};
-use super::ethereum_types::{Address, H256};
-use super::{Encodable, SszStream};
-
-/*
- * Note: there is a "to_bytes" function for integers
- * in Rust nightly. When it is in stable, we should
- * use it instead.
- */
-macro_rules! impl_encodable_for_uint {
-    ($type: ident, $bit_size: expr) => {
-        impl Encodable for $type {
-            #[allow(clippy::cast_lossless)]
-            fn ssz_append(&self, s: &mut SszStream) {
-                // Ensure bit size is valid
-                assert!(
-                    (0 < $bit_size)
-                        && ($bit_size % 8 == 0)
-                        && (2_u128.pow($bit_size) > *self as u128)
-                );
-
-                // Serialize to bytes
-                let mut buf = BytesMut::with_capacity($bit_size / 8);
-
-                // Match bit size with encoding
-                match $bit_size {
-                    8 => buf.put_u8(*self as u8),
-                    16 => buf.put_u16_be(*self as u16),
-                    32 => buf.put_u32_be(*self as u32),
-                    64 => buf.put_u64_be(*self as u64),
-                    _ => {}
-                }
-
-                // Append bytes to the SszStream
-                s.append_encoded_raw(&buf.to_vec());
-            }
-        }
-    };
-}
-
-impl_encodable_for_uint!(u8, 8);
-impl_encodable_for_uint!(u16, 16);
-impl_encodable_for_uint!(u32, 32);
-impl_encodable_for_uint!(u64, 64);
-impl_encodable_for_uint!(usize, 64);
-
-impl Encodable for H256 {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_encoded_raw(&self.to_vec());
-    }
-}
-
-impl Encodable for Address {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_encoded_raw(&self.to_vec());
-    }
-}
-
-impl<T> Encodable for Vec<T>
-where
-    T: Encodable,
-{
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_ssz_encode_h256() {
-        let h = H256::zero();
-        let mut ssz = SszStream::new();
-        ssz.append(&h);
-        assert_eq!(ssz.drain(), vec![0; 32]);
-    }
-
-    #[test]
-    fn test_ssz_encode_address() {
-        let h = Address::zero();
-        let mut ssz = SszStream::new();
-        ssz.append(&h);
-        assert_eq!(ssz.drain(), vec![0; 20]);
-    }
-
-    #[test]
-    fn test_ssz_encode_u8() {
-        let x: u8 = 0;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0]);
-
-        let x: u8 = 1;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![1]);
-
-        let x: u8 = 100;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![100]);
-
-        let x: u8 = 255;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![255]);
-    }
-
-    #[test]
-    fn test_ssz_encode_u16() {
-        let x: u16 = 1;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 1]);
-
-        let x: u16 = 100;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 100]);
-
-        let x: u16 = 1 << 8;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![1, 0]);
-
-        let x: u16 = 65535;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![255, 255]);
-    }
-
-    #[test]
-    fn test_ssz_encode_u32() {
-        let x: u32 = 1;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1]);
-
-        let x: u32 = 100;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 100]);
-
-        let x: u32 = 1 << 16;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 1, 0, 0]);
-
-        let x: u32 = 1 << 24;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![1, 0, 0, 0]);
-
-        let x: u32 = !0;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![255, 255, 255, 255]);
-    }
-
-    #[test]
-    fn test_ssz_encode_u64() {
-        let x: u64 = 1;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 1]);
-
-        let x: u64 = 100;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 100]);
-
-        let x: u64 = 1 << 32;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1, 0, 0, 0, 0]);
-
-        let x: u64 = !0;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
-    }
-
-    #[test]
-    fn test_ssz_encode_usize() {
-        let x: usize = 1;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 1]);
-
-        let x: usize = 100;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 100]);
-
-        let x: usize = 1 << 32;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1, 0, 0, 0, 0]);
-
-        let x: usize = !0;
-        let mut ssz = SszStream::new();
-        ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
-    }
-}

eth2/utils/ssz/src/impl_tree_hash.rs

@@ -1,79 +0,0 @@
-use super::ethereum_types::{Address, H256};
-use super::{merkle_hash, ssz_encode, TreeHash};
-use hashing::hash;
-
-impl TreeHash for u8 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u16 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u32 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for u64 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for usize {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for Address {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for H256 {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        ssz_encode(self)
-    }
-}
-
-impl TreeHash for [u8] {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        if self.len() > 32 {
-            return hash(&self);
-        }
-        self.to_vec()
-    }
-}
-
-impl<T> TreeHash for Vec<T>
-where
-    T: TreeHash,
-{
-    /// Returns the merkle_hash of a list of hash_tree_root values created
-    /// from the given list.
-    /// Note: A byte vector, Vec<u8>, must be converted to a slice (as_slice())
-    ///       to be handled properly (i.e. hashed) as byte array.
-    fn hash_tree_root(&self) -> Vec<u8> {
-        let mut tree_hashes = self.iter().map(|x| x.hash_tree_root()).collect();
-        merkle_hash(&mut tree_hashes)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_impl_tree_hash_vec() {
-        let result = vec![1u32, 2, 3, 4, 5, 6, 7].hash_tree_root();
-        assert_eq!(result.len(), 32);
-    }
-}

eth2/utils/ssz/src/lib.rs

@@ -1,38 +0,0 @@
-/*
- * This is a WIP of implementing an alternative
- * serialization strategy. It attempts to follow Vitalik's
- * "simpleserialize" format here:
- * https://github.com/ethereum/beacon_chain/blob/master/beacon_chain/utils/simpleserialize.py
- *
- * This implementation is not final and would almost certainly
- * have issues.
- */
-extern crate bytes;
-extern crate ethereum_types;
-
-pub mod decode;
-pub mod encode;
-pub mod tree_hash;
-
-mod impl_decode;
-mod impl_encode;
-mod impl_tree_hash;
-
-pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
-pub use crate::encode::{Encodable, SszStream};
-pub use crate::tree_hash::{merkle_hash, TreeHash};
-
-pub use hashing::hash;
-
-pub const LENGTH_BYTES: usize = 4;
-pub const MAX_LIST_SIZE: usize = 1 << (4 * 8);
-
-/// Convenience function to SSZ encode an object supporting ssz::Encode.
-pub fn ssz_encode<T>(val: &T) -> Vec<u8>
-where
-    T: Encodable,
-{
-    let mut ssz_stream = SszStream::new();
-    ssz_stream.append(val);
-    ssz_stream.drain()
-}

eth2/utils/ssz/src/tree_hash.rs

@@ -1,83 +0,0 @@
-use hashing::hash;
-
-const SSZ_CHUNK_SIZE: usize = 128;
-const HASHSIZE: usize = 32;
-
-pub trait TreeHash {
-    fn hash_tree_root(&self) -> Vec<u8>;
-}
-
-/// Returns a 32 byte hash of 'list' - a vector of byte vectors.
-/// Note that this will consume 'list'.
-pub fn merkle_hash(list: &mut Vec<Vec<u8>>) -> Vec<u8> {
-    // flatten list
-    let (mut chunk_size, mut chunkz) = list_to_blob(list);
-
-    // get data_len as bytes. It will hashed will the merkle root
-    let datalen = list.len().to_le_bytes();
-
-    // Tree-hash
-    while chunkz.len() > HASHSIZE {
-        let mut new_chunkz: Vec<u8> = Vec::new();
-
-        for two_chunks in chunkz.chunks(chunk_size * 2) {
-            if two_chunks.len() == chunk_size {
-                // Odd number of chunks
-                let mut c = two_chunks.to_vec();
-                c.append(&mut vec![0; SSZ_CHUNK_SIZE]);
-                new_chunkz.append(&mut hash(&c));
-            } else {
-                // Hash two chuncks together
-                new_chunkz.append(&mut hash(two_chunks));
-            }
-        }
-
-        chunk_size = HASHSIZE;
-        chunkz = new_chunkz;
-    }
-
-    chunkz.append(&mut datalen.to_vec());
-    hash(&chunkz)
-}
-
-fn list_to_blob(list: &mut Vec<Vec<u8>>) -> (usize, Vec<u8>) {
-    let chunk_size = if list.is_empty() {
-        SSZ_CHUNK_SIZE
-    } else if list[0].len() < SSZ_CHUNK_SIZE {
-        let items_per_chunk = SSZ_CHUNK_SIZE / list[0].len();
-        items_per_chunk * list[0].len()
-    } else {
-        list[0].len()
-    };
-
-    let mut data = Vec::new();
-    if list.is_empty() {
-        // handle and empty list
-        data.append(&mut vec![0; SSZ_CHUNK_SIZE]);
-    } else {
-        // just create a blob here; we'll divide into
-        // chunked slices when we merklize
-        data.reserve(list[0].len() * list.len());
-        for item in list.iter_mut() {
-            data.append(item);
-        }
-    }
-    (chunk_size, data)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_merkle_hash() {
-        let data1 = vec![1; 100];
-        let data2 = vec![2; 100];
-        let data3 = vec![3; 100];
-        let mut list = vec![data1, data2, data3];
-        let result = merkle_hash(&mut list);
-
-        //note: should test againt a known test hash value
-        assert_eq!(HASHSIZE, result.len());
-    }
-}

eth2/utils/vec_shuffle/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "vec_shuffle"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-hashing = { path = "../hashing" }
-
-[dev-dependencies]
-yaml-rust = "0.4.2"

eth2/utils/vec_shuffle/src/lib.rs

@@ -1,81 +0,0 @@
-/// A library for performing deterministic, pseudo-random shuffling on a vector.
-///
-/// This library is designed to confirm to the Ethereum 2.0 specification.
-extern crate hashing;
-
-mod rng;
-
-use self::rng::ShuffleRng;
-
-#[derive(Debug)]
-pub enum ShuffleErr {
-    ExceedsListLength,
-}
-
-/// Performs a deterministic, in-place shuffle of a vector.
-///
-/// The final order of the shuffle is determined by successive hashes
-/// of the supplied `seed`.
-///
-/// This is a Fisher-Yates-Durtstenfeld shuffle.
-pub fn shuffle<T>(seed: &[u8], mut list: Vec<T>) -> Result<Vec<T>, ShuffleErr> {
-    let mut rng = ShuffleRng::new(seed);
-
-    if list.len() > rng.rand_max as usize {
-        return Err(ShuffleErr::ExceedsListLength);
-    }
-
-    if list.is_empty() {
-        return Ok(list);
-    }
-
-    for i in 0..(list.len() - 1) {
-        let n = list.len() - i;
-        let j = rng.rand_range(n as u32) as usize + i;
-        list.swap(i, j);
-    }
-    Ok(list)
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate yaml_rust;
-
-    use self::yaml_rust::yaml;
-
-    use std::{fs::File, io::prelude::*, path::PathBuf};
-
-    use super::{hashing::hash, *};
-
-    #[test]
-    fn test_shuffling() {
-        let mut file = {
-            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-            file_path_buf.push("src/specs/shuffle_test_vectors.yaml");
-
-            File::open(file_path_buf).unwrap()
-        };
-
-        let mut yaml_str = String::new();
-
-        file.read_to_string(&mut yaml_str).unwrap();
-
-        let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
-        let doc = &docs[0];
-        let test_cases = doc["test_cases"].as_vec().unwrap();
-
-        for test_case in test_cases {
-            let input = test_case["input"].clone().into_vec().unwrap();
-            let output = test_case["output"].clone().into_vec().unwrap();
-            let seed_bytes = test_case["seed"].as_str().unwrap().as_bytes();
-
-            let seed = if seed_bytes.len() > 0 {
-                hash(seed_bytes)
-            } else {
-                vec![]
-            };
-
-            assert_eq!(shuffle(&seed, input).unwrap(), output);
-        }
-    }
-}

eth2/utils/vec_shuffle/src/rng.rs

@@ -1,90 +0,0 @@
-use super::hashing::hash;
-
-const SEED_SIZE_BYTES: usize = 32;
-const RAND_BYTES: usize = 3; // 24 / 8
-const RAND_MAX: u32 = 16_777_215; // 2 ** (rand_bytes * 8) - 1
-
-/// A pseudo-random number generator which given a seed
-/// uses successive blake2s hashing to generate "entropy".
-pub struct ShuffleRng {
-    seed: Vec<u8>,
-    idx: usize,
-    pub rand_max: u32,
-}
-
-impl ShuffleRng {
-    /// Create a new instance given some "seed" bytes.
-    pub fn new(initial_seed: &[u8]) -> Self {
-        Self {
-            seed: hash(initial_seed),
-            idx: 0,
-            rand_max: RAND_MAX,
-        }
-    }
-
-    /// "Regenerates" the seed by hashing it.
-    fn rehash_seed(&mut self) {
-        self.seed = hash(&self.seed);
-        self.idx = 0;
-    }
-
-    /// Extracts 3 bytes from the `seed`. Rehashes seed if required.
-    fn rand(&mut self) -> u32 {
-        self.idx += RAND_BYTES;
-        if self.idx >= SEED_SIZE_BYTES {
-            self.rehash_seed();
-            self.rand()
-        } else {
-            int_from_byte_slice(&self.seed, self.idx - RAND_BYTES)
-        }
-    }
-
-    /// Generate a random u32 below the specified maximum `n`.
-    ///
-    /// Provides a filtered result from a higher-level rng, by discarding
-    /// results which may bias the output. Because of this, execution time is
-    /// not linear and may potentially be infinite.
-    pub fn rand_range(&mut self, n: u32) -> u32 {
-        assert!(n < RAND_MAX, "RAND_MAX exceed");
-        let mut x = self.rand();
-        while x >= self.rand_max - (self.rand_max % n) {
-            x = self.rand();
-        }
-        x % n
-    }
-}
-
-/// Reads the next three bytes of `source`, starting from `offset` and
-/// interprets those bytes as a 24 bit big-endian integer.
-/// Returns that integer.
-fn int_from_byte_slice(source: &[u8], offset: usize) -> u32 {
-    (u32::from(source[offset + 2]))
-        | (u32::from(source[offset + 1]) << 8)
-        | (u32::from(source[offset]) << 16)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_shuffling_int_from_slice() {
-        let mut x = int_from_byte_slice(&[0, 0, 1], 0);
-        assert_eq!((x as u32), 1);
-
-        x = int_from_byte_slice(&[0, 1, 1], 0);
-        assert_eq!(x, 257);
-
-        x = int_from_byte_slice(&[1, 1, 1], 0);
-        assert_eq!(x, 65793);
-
-        x = int_from_byte_slice(&[255, 1, 1], 0);
-        assert_eq!(x, 16711937);
-
-        x = int_from_byte_slice(&[255, 255, 255], 0);
-        assert_eq!(x, 16777215);
-
-        x = int_from_byte_slice(&[0x8f, 0xbb, 0xc7], 0);
-        assert_eq!(x, 9419719);
-    }
-}

eth2/utils/vec_shuffle/src/specs/shuffle_test_vectors.yaml

@@ -1,131 +0,0 @@
-title: Shuffling Algorithm Tests
-summary: Test vectors for shuffling a list based upon a seed.
-test_suite: Shuffling
-
-test_cases:
-- input: []
-  output: []
-  seed: ''
-- input: [0]
-  output: [0]
-  seed: ''
-- input: [255]
-  output: [255]
-  seed: ''
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 1, 1, 5, 6, 6, 6, 2, 4, 4]
-  seed: ''
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [4, 9, 6, 8, 13, 3, 2, 11, 5, 1, 12, 7, 10]
-  seed: ''
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 1, 1, 5, 6, 6, 6, 2, 4, 65]
-  seed: ''
-- input: []
-  output: []
-  seed: 4kn4driuctg8
-- input: [0]
-  output: [0]
-  seed: 4kn4driuctg8
-- input: [255]
-  output: [255]
-  seed: 4kn4driuctg8
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 4, 4, 2, 1, 1, 6, 5, 6, 6]
-  seed: 4kn4driuctg8
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [7, 6, 3, 12, 11, 1, 8, 13, 10, 5, 9, 4, 2]
-  seed: 4kn4driuctg8
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 4, 65, 2, 1, 1, 6, 5, 6, 6]
-  seed: 4kn4driuctg8
-- input: []
-  output: []
-  seed: ytre1p
-- input: [0]
-  output: [0]
-  seed: ytre1p
-- input: [255]
-  output: [255]
-  seed: ytre1p
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 1, 1, 5, 6, 2, 6, 2, 4, 4]
-  seed: ytre1p
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [6, 2, 3, 4, 8, 5, 12, 9, 7, 11, 10, 1, 13]
-  seed: ytre1p
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 1, 1, 5, 6, 2, 6, 2, 4, 65]
-  seed: ytre1p
-- input: []
-  output: []
-  seed: mytobcffnkvj
-- input: [0]
-  output: [0]
-  seed: mytobcffnkvj
-- input: [255]
-  output: [255]
-  seed: mytobcffnkvj
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 4, 1, 1, 6, 4, 6, 5, 6, 2]
-  seed: mytobcffnkvj
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [11, 5, 9, 7, 2, 4, 12, 10, 8, 1, 6, 3, 13]
-  seed: mytobcffnkvj
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 65, 1, 1, 6, 4, 6, 5, 6, 2]
-  seed: mytobcffnkvj
-- input: []
-  output: []
-  seed: myzu3g7evxp5nkvj
-- input: [0]
-  output: [0]
-  seed: myzu3g7evxp5nkvj
-- input: [255]
-  output: [255]
-  seed: myzu3g7evxp5nkvj
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 2, 1, 4, 2, 6, 5, 6, 4, 1]
-  seed: myzu3g7evxp5nkvj
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [2, 1, 11, 3, 9, 7, 8, 13, 4, 10, 5, 6, 12]
-  seed: myzu3g7evxp5nkvj
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 2, 1, 4, 2, 6, 5, 6, 65, 1]
-  seed: myzu3g7evxp5nkvj
-- input: []
-  output: []
-  seed: xdpli1jsx5xb
-- input: [0]
-  output: [0]
-  seed: xdpli1jsx5xb
-- input: [255]
-  output: [255]
-  seed: xdpli1jsx5xb
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 1, 2, 4, 6, 6, 5, 6, 1, 4]
-  seed: xdpli1jsx5xb
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [5, 8, 12, 9, 11, 4, 7, 13, 1, 3, 2, 10, 6]
-  seed: xdpli1jsx5xb
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [2, 1, 2, 65, 6, 6, 5, 6, 1, 4]
-  seed: xdpli1jsx5xb
-- input: []
-  output: []
-  seed: oab3mbb3xe8qsx5xb
-- input: [0]
-  output: [0]
-  seed: oab3mbb3xe8qsx5xb
-- input: [255]
-  output: [255]
-  seed: oab3mbb3xe8qsx5xb
-- input: [4, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 2, 1, 1, 6, 2, 4, 4, 6, 5]
-  seed: oab3mbb3xe8qsx5xb
-- input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
-  output: [1, 8, 5, 13, 2, 10, 7, 11, 12, 6, 3, 4, 9]
-  seed: oab3mbb3xe8qsx5xb
-- input: [65, 6, 2, 6, 1, 4, 6, 2, 1, 5]
-  output: [6, 2, 1, 1, 6, 2, 4, 65, 6, 5]
-  seed: oab3mbb3xe8qsx5xb

eth2/validator_change/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "validator_change"
-version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
-edition = "2018"
-
-[dependencies]
-bytes = "0.4.10"
-hashing = { path = "../utils/hashing" }
-ssz = { path = "../utils/ssz" }
-types = { path = "../types" }

eth2/validator_change/src/lib.rs

@@ -1,142 +0,0 @@
-extern crate bytes;
-extern crate hashing;
-extern crate types;
-
-use bytes::{BufMut, BytesMut};
-use hashing::canonical_hash;
-use ssz::ssz_encode;
-use std::cmp::max;
-use types::{Hash256, ValidatorRecord, ValidatorStatus};
-
-pub enum UpdateValidatorSetError {
-    ArithmeticOverflow,
-}
-
-const VALIDATOR_FLAG_ENTRY: u8 = 0;
-const VALIDATOR_FLAG_EXIT: u8 = 1;
-
-pub fn update_validator_set(
-    validators: &mut Vec<ValidatorRecord>,
-    hash_chain: Hash256,
-    present_slot: u64,
-    deposit_size_gwei: u64,
-    max_validator_churn_quotient: u64,
-) -> Result<(), UpdateValidatorSetError> {
-    /*
-     * Total balance of all active validators.
-     *
-     * Return an error if an overflow occurs.
-     */
-    let total_balance = {
-        let mut bal: u64 = 0;
-        for v in validators.iter() {
-            if v.status_is(ValidatorStatus::Active) {
-                bal = bal
-                    .checked_add(v.balance)
-                    .ok_or(UpdateValidatorSetError::ArithmeticOverflow)?;
-            }
-        }
-        bal
-    };
-
-    /*
-     * Note: this is not the maximum allowable change, it can actually be higher.
-     */
-    let max_allowable_change = {
-        let double_deposit_size = deposit_size_gwei
-            .checked_mul(2)
-            .ok_or(UpdateValidatorSetError::ArithmeticOverflow)?;
-        max(
-            double_deposit_size,
-            total_balance / max_validator_churn_quotient,
-        )
-    };
-
-    let mut hasher = ValidatorChangeHashChain {
-        bytes: hash_chain.to_vec(),
-    };
-    let mut total_changed: u64 = 0;
-    for (i, v) in validators.iter_mut().enumerate() {
-        match v.status {
-            /*
-             * Validator is pending activiation.
-             */
-            ValidatorStatus::PendingActivation => {
-                let new_total_changed = total_changed
-                    .checked_add(deposit_size_gwei)
-                    .ok_or(UpdateValidatorSetError::ArithmeticOverflow)?;
-                /*
-                 * If entering this validator would not exceed the max balance delta,
-                 * activate the validator.
-                 */
-                if new_total_changed <= max_allowable_change {
-                    v.status = ValidatorStatus::Active;
-                    hasher.extend(i, &ssz_encode(&v.pubkey), VALIDATOR_FLAG_ENTRY);
-                    total_changed = new_total_changed;
-                } else {
-                    // Entering the validator would exceed the balance delta.
-                    break;
-                }
-            }
-            /*
-             * Validator is pending exit.
-             */
-            ValidatorStatus::PendingExit => {
-                let new_total_changed = total_changed
-                    .checked_add(v.balance)
-                    .ok_or(UpdateValidatorSetError::ArithmeticOverflow)?;
-                /*
-                 * If exiting this validator would not exceed the max balance delta,
-                 * exit the validator
-                 */
-                if new_total_changed <= max_allowable_change {
-                    v.status = ValidatorStatus::PendingWithdraw;
-                    v.exit_slot = present_slot;
-                    hasher.extend(i, &ssz_encode(&v.pubkey), VALIDATOR_FLAG_EXIT);
-                    total_changed = new_total_changed;
-                } else {
-                    // Exiting the validator would exceed the balance delta.
-                    break;
-                }
-            }
-            _ => (),
-        };
-        if total_changed >= max_allowable_change {
-            break;
-        }
-    }
-    Ok(())
-}
-
-pub struct ValidatorChangeHashChain {
-    bytes: Vec<u8>,
-}
-
-impl ValidatorChangeHashChain {
-    pub fn extend(&mut self, index: usize, pubkey: &Vec<u8>, flag: u8) {
-        let mut message = self.bytes.clone();
-        message.append(&mut serialize_validator_change_record(index, pubkey, flag));
-        self.bytes = canonical_hash(&message);
-    }
-}
-
-fn serialize_validator_change_record(index: usize, pubkey: &Vec<u8>, flag: u8) -> Vec<u8> {
-    let mut buf = BytesMut::with_capacity(68);
-    buf.put_u8(flag);
-    let index_bytes = {
-        let mut buf = BytesMut::with_capacity(8);
-        buf.put_u64_be(index as u64);
-        buf.take()[8 - 3..8].to_vec()
-    };
-    buf.put(index_bytes);
-    buf.put(pubkey);
-    buf.take().to_vec()
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}