Directory Restructure (#1163)

* Move tests -> testing

* Directory restructure

* Update Cargo.toml during restructure

* Update Makefile during restructure

* Fix arbitrary path

common/rest_types/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rest_types"
+version = "0.2.0"
+authors = ["Age Manning <Age@AgeManning.com>"]
+edition = "2018"
+
+[dependencies]
+types = { path = "../../consensus/types" }
+eth2_ssz_derive = "0.1.0"
+eth2_ssz = "0.1.2"
+eth2_hashing = "0.1.0"
+tree_hash = "0.1.0"
+state_processing = { path = "../../consensus/state_processing" }
+bls = { path = "../../crypto/bls" }
+serde = { version = "1.0.110", features = ["derive"] }
+rayon = "1.3.0"

common/rest_types/src/beacon.rs

@@ -0,0 +1,65 @@
+//! A collection of REST API types for interaction with the beacon node.
+
+use bls::PublicKeyBytes;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use types::beacon_state::EthSpec;
+use types::{BeaconState, CommitteeIndex, Hash256, SignedBeaconBlock, Slot, Validator};
+
+/// Information about a block that is at the head of a chain. May or may not represent the
+/// canonical head.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+pub struct HeadBeaconBlock {
+    pub beacon_block_root: Hash256,
+    pub beacon_block_slot: Slot,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+#[serde(bound = "T: EthSpec")]
+pub struct BlockResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_block: SignedBeaconBlock<T>,
+}
+
+/// Information about the block and state that are at head of the beacon chain.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+pub struct CanonicalHeadResponse {
+    pub slot: Slot,
+    pub block_root: Hash256,
+    pub state_root: Hash256,
+    pub finalized_slot: Slot,
+    pub finalized_block_root: Hash256,
+    pub justified_slot: Slot,
+    pub justified_block_root: Hash256,
+    pub previous_justified_slot: Slot,
+    pub previous_justified_block_root: Hash256,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+pub struct ValidatorResponse {
+    pub pubkey: PublicKeyBytes,
+    pub validator_index: Option<usize>,
+    pub balance: Option<u64>,
+    pub validator: Option<Validator>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+pub struct ValidatorRequest {
+    /// If set to `None`, uses the canonical head state.
+    pub state_root: Option<Hash256>,
+    pub pubkeys: Vec<PublicKeyBytes>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+pub struct Committee {
+    pub slot: Slot,
+    pub index: CommitteeIndex,
+    pub committee: Vec<usize>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+#[serde(bound = "T: EthSpec")]
+pub struct StateResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_state: BeaconState<T>,
+}

common/rest_types/src/consensus.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use state_processing::per_epoch_processing::ValidatorStatus;
+use types::{Epoch, PublicKeyBytes};
+
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
+pub struct IndividualVotesRequest {
+    pub epoch: Epoch,
+    pub pubkeys: Vec<PublicKeyBytes>,
+}
+
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
+pub struct IndividualVote {
+    /// True if the validator has been slashed, ever.
+    pub is_slashed: bool,
+    /// True if the validator can withdraw in the current epoch.
+    pub is_withdrawable_in_current_epoch: bool,
+    /// True if the validator was active in the state's _current_ epoch.
+    pub is_active_in_current_epoch: bool,
+    /// True if the validator was active in the state's _previous_ epoch.
+    pub is_active_in_previous_epoch: bool,
+    /// The validator's effective balance in the _current_ epoch.
+    pub current_epoch_effective_balance_gwei: u64,
+    /// True if the validator had an attestation included in the _current_ epoch.
+    pub is_current_epoch_attester: bool,
+    /// True if the validator's beacon block root attestation for the first slot of the _current_
+    /// epoch matches the block root known to the state.
+    pub is_current_epoch_target_attester: bool,
+    /// True if the validator had an attestation included in the _previous_ epoch.
+    pub is_previous_epoch_attester: bool,
+    /// True if the validator's beacon block root attestation for the first slot of the _previous_
+    /// epoch matches the block root known to the state.
+    pub is_previous_epoch_target_attester: bool,
+    /// True if the validator's beacon block root attestation in the _previous_ epoch at the
+    /// attestation's slot (`attestation_data.slot`) matches the block root known to the state.
+    pub is_previous_epoch_head_attester: bool,
+}
+
+impl Into<IndividualVote> for ValidatorStatus {
+    fn into(self) -> IndividualVote {
+        IndividualVote {
+            is_slashed: self.is_slashed,
+            is_withdrawable_in_current_epoch: self.is_withdrawable_in_current_epoch,
+            is_active_in_current_epoch: self.is_active_in_current_epoch,
+            is_active_in_previous_epoch: self.is_active_in_previous_epoch,
+            current_epoch_effective_balance_gwei: self.current_epoch_effective_balance,
+            is_current_epoch_attester: self.is_current_epoch_attester,
+            is_current_epoch_target_attester: self.is_current_epoch_target_attester,
+            is_previous_epoch_attester: self.is_previous_epoch_attester,
+            is_previous_epoch_target_attester: self.is_previous_epoch_target_attester,
+            is_previous_epoch_head_attester: self.is_previous_epoch_head_attester,
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
+pub struct IndividualVotesResponse {
+    /// The epoch which is considered the "current" epoch.
+    pub epoch: Epoch,
+    /// The validators public key.
+    pub pubkey: PublicKeyBytes,
+    /// The index of the validator in state.validators.
+    pub validator_index: Option<usize>,
+    /// Voting statistics for the validator, if they voted in the given epoch.
+    pub vote: Option<IndividualVote>,
+}

common/rest_types/src/lib.rs

@@ -0,0 +1,21 @@
+//! A collection of types used to pass data across the rest HTTP API.
+//!
+//! This is primarily used by the validator client and the beacon node rest API.
+
+mod beacon;
+mod consensus;
+mod node;
+mod validator;
+
+pub use beacon::{
+    BlockResponse, CanonicalHeadResponse, Committee, HeadBeaconBlock, StateResponse,
+    ValidatorRequest, ValidatorResponse,
+};
+
+pub use validator::{
+    ValidatorDutiesRequest, ValidatorDuty, ValidatorDutyBytes, ValidatorSubscription,
+};
+
+pub use consensus::{IndividualVote, IndividualVotesRequest, IndividualVotesResponse};
+
+pub use node::{SyncingResponse, SyncingStatus};

common/rest_types/src/node.rs

@@ -0,0 +1,32 @@
+//! Collection of types for the /node HTTP
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use types::Slot;
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+/// The current syncing status of the node.
+pub struct SyncingStatus {
+    /// The starting slot of sync.
+    ///
+    /// For a finalized sync, this is the start slot of the current finalized syncing
+    /// chain.
+    ///
+    /// For head sync this is the last finalized slot.
+    pub starting_slot: Slot,
+    /// The current slot.
+    pub current_slot: Slot,
+    /// The highest known slot. For the current syncing chain.
+    ///
+    /// For a finalized sync, the target finalized slot.
+    /// For head sync, this is the highest known slot of all head chains.
+    pub highest_slot: Slot,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)]
+/// The response for the /node/syncing HTTP GET.
+pub struct SyncingResponse {
+    /// Is the node syncing.
+    pub is_syncing: bool,
+    /// The current sync status.
+    pub sync_status: SyncingStatus,
+}

common/rest_types/src/validator.rs

@@ -0,0 +1,72 @@
+use bls::{PublicKey, PublicKeyBytes, Signature};
+use eth2_hashing::hash;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use std::convert::TryInto;
+use types::{CommitteeIndex, Epoch, Slot};
+
+/// A Validator duty with the validator public key represented a `PublicKeyBytes`.
+pub type ValidatorDutyBytes = ValidatorDutyBase<PublicKeyBytes>;
+/// A validator duty with the pubkey represented as a `PublicKey`.
+pub type ValidatorDuty = ValidatorDutyBase<PublicKey>;
+
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
+pub struct ValidatorDutyBase<T> {
+    /// The validator's BLS public key, uniquely identifying them. _48-bytes, hex encoded with 0x prefix, case insensitive._
+    pub validator_pubkey: T,
+    /// The validator's index in `state.validators`
+    pub validator_index: Option<u64>,
+    /// The slot at which the validator must attest.
+    pub attestation_slot: Option<Slot>,
+    /// The index of the committee within `slot` of which the validator is a member.
+    pub attestation_committee_index: Option<CommitteeIndex>,
+    /// The position of the validator in the committee.
+    pub attestation_committee_position: Option<usize>,
+    /// The slots in which a validator must propose a block (can be empty).
+    pub block_proposal_slots: Vec<Slot>,
+    /// This provides the modulo: `max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE)`
+    /// which allows the validator client to determine if this duty requires the validator to be
+    /// aggregate attestations.
+    pub aggregator_modulo: Option<u64>,
+}
+
+impl<T> ValidatorDutyBase<T> {
+    /// Given a `slot_signature` determines if the validator of this duty is an aggregator.
+    // Note that we assume the signature is for the associated pubkey to avoid the signature
+    // verification
+    pub fn is_aggregator(&self, slot_signature: &Signature) -> bool {
+        if let Some(modulo) = self.aggregator_modulo {
+            let signature_hash = hash(&slot_signature.as_bytes());
+            let signature_hash_int = u64::from_le_bytes(
+                signature_hash[0..8]
+                    .try_into()
+                    .expect("first 8 bytes of signature should always convert to fixed array"),
+            );
+            signature_hash_int % modulo == 0
+        } else {
+            false
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
+pub struct ValidatorDutiesRequest {
+    pub epoch: Epoch,
+    pub pubkeys: Vec<PublicKeyBytes>,
+}
+
+/// A validator subscription, created when a validator subscribes to a slot to perform optional aggregation
+/// duties.
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone, Encode, Decode)]
+pub struct ValidatorSubscription {
+    /// The validators index.
+    pub validator_index: u64,
+    /// The index of the committee within `slot` of which the validator is a member. Used by the
+    /// beacon node to quickly evaluate the associated `SubnetId`.
+    pub attestation_committee_index: CommitteeIndex,
+    /// The slot in which to subscribe.
+    pub slot: Slot,
+    /// If true, the validator is an aggregator and the beacon node should aggregate attestations
+    /// for this slot.
+    pub is_aggregator: bool,
+}