Merge branch 'unstable' into dvt

common/eth2/src/lib.rs

@@ -16,11 +16,12 @@ pub mod types;
 
 use self::mixin::{RequestAccept, ResponseOptional};
 use self::types::{Error as ResponseError, *};
+use ::types::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedResponse;
 use derivative::Derivative;
 use either::Either;
 use futures::Stream;
 use futures_util::StreamExt;
-use lighthouse_network::PeerId;
+use libp2p_identity::PeerId;
 use pretty_reqwest_error::PrettyReqwestError;
 pub use reqwest;
 use reqwest::{
@@ -36,7 +37,6 @@ use std::fmt;
 use std::future::Future;
 use std::path::PathBuf;
 use std::time::Duration;
-use store::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedResponse;
 
 pub const V1: EndpointVersion = EndpointVersion(1);
 pub const V2: EndpointVersion = EndpointVersion(2);
@@ -333,7 +333,6 @@ impl BeaconNodeHttpClient {
     }
 
     /// Perform a HTTP POST request, returning a JSON response.
-    #[cfg(feature = "lighthouse")]
     async fn post_with_response<T: Serialize, U: IntoUrl, R: DeserializeOwned>(
         &self,
         url: U,
@@ -786,6 +785,45 @@ impl BeaconNodeHttpClient {
         self.get_opt(path).await
     }
 
+    /// `GET beacon/states/{state_id}/pending_deposits`
+    ///
+    /// Returns `Ok(None)` on a 404 error.
+    pub async fn get_beacon_states_pending_deposits(
+        &self,
+        state_id: StateId,
+    ) -> Result<Option<ExecutionOptimisticFinalizedResponse<Vec<PendingDeposit>>>, Error> {
+        let mut path = self.eth_path(V1)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("states")
+            .push(&state_id.to_string())
+            .push("pending_deposits");
+
+        self.get_opt(path).await
+    }
+
+    /// `GET beacon/states/{state_id}/pending_partial_withdrawals`
+    ///
+    /// Returns `Ok(None)` on a 404 error.
+    pub async fn get_beacon_states_pending_partial_withdrawals(
+        &self,
+        state_id: StateId,
+    ) -> Result<Option<ExecutionOptimisticFinalizedResponse<Vec<PendingPartialWithdrawal>>>, Error>
+    {
+        let mut path = self.eth_path(V1)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("states")
+            .push(&state_id.to_string())
+            .push("pending_partial_withdrawals");
+
+        self.get_opt(path).await
+    }
+
     /// `GET beacon/light_client/updates`
     ///
     /// Returns `Ok(None)` on a 404 error.
@@ -1606,33 +1644,34 @@ impl BeaconNodeHttpClient {
     /// `POST beacon/rewards/sync_committee`
     pub async fn post_beacon_rewards_sync_committee(
         &self,
-        rewards: &[Option<Vec<lighthouse::SyncCommitteeReward>>],
-    ) -> Result<(), Error> {
+        block_id: BlockId,
+        validators: &[ValidatorId],
+    ) -> Result<GenericResponse<Vec<SyncCommitteeReward>>, Error> {
         let mut path = self.eth_path(V1)?;
 
         path.path_segments_mut()
             .map_err(|()| Error::InvalidUrl(self.server.clone()))?
             .push("beacon")
             .push("rewards")
-            .push("sync_committee");
+            .push("sync_committee")
+            .push(&block_id.to_string());
 
-        self.post(path, &rewards).await?;
-
-        Ok(())
+        self.post_with_response(path, &validators).await
     }
 
     /// `GET beacon/rewards/blocks`
-    pub async fn get_beacon_rewards_blocks(&self, epoch: Epoch) -> Result<(), Error> {
+    pub async fn get_beacon_rewards_blocks(
+        &self,
+        block_id: BlockId,
+    ) -> Result<GenericResponse<StandardBlockReward>, Error> {
         let mut path = self.eth_path(V1)?;
 
         path.path_segments_mut()
             .map_err(|()| Error::InvalidUrl(self.server.clone()))?
             .push("beacon")
             .push("rewards")
-            .push("blocks");
-
-        path.query_pairs_mut()
-            .append_pair("epoch", &epoch.to_string());
+            .push("blocks")
+            .push(&block_id.to_string());
 
         self.get(path).await
     }
@@ -1640,19 +1679,19 @@ impl BeaconNodeHttpClient {
     /// `POST beacon/rewards/attestations`
     pub async fn post_beacon_rewards_attestations(
         &self,
-        attestations: &[ValidatorId],
-    ) -> Result<(), Error> {
+        epoch: Epoch,
+        validators: &[ValidatorId],
+    ) -> Result<StandardAttestationRewards, Error> {
         let mut path = self.eth_path(V1)?;
 
         path.path_segments_mut()
             .map_err(|()| Error::InvalidUrl(self.server.clone()))?
             .push("beacon")
             .push("rewards")
-            .push("attestations");
+            .push("attestations")
+            .push(&epoch.to_string());
 
-        self.post(path, &attestations).await?;
-
-        Ok(())
+        self.post_with_response(path, &validators).await
     }
 
     // GET builder/states/{state_id}/expected_withdrawals

common/eth2/src/lighthouse.rs

@@ -1,15 +1,15 @@
 //! This module contains endpoints that are non-standard and only available on Lighthouse servers.
 
 mod attestation_performance;
-pub mod attestation_rewards;
 mod block_packing_efficiency;
 mod block_rewards;
-mod standard_block_rewards;
-mod sync_committee_rewards;
+pub mod sync_state;
 
 use crate::{
+    lighthouse::sync_state::SyncState,
     types::{
-        DepositTreeSnapshot, Epoch, EthSpec, FinalizedExecutionBlock, GenericResponse, ValidatorId,
+        AdminPeer, DepositTreeSnapshot, Epoch, FinalizedExecutionBlock, GenericResponse,
+        ValidatorId,
     },
     BeaconNodeHttpClient, DepositData, Error, Eth1Data, Hash256, Slot,
 };
@@ -17,36 +17,20 @@ use proto_array::core::ProtoArray;
 use serde::{Deserialize, Serialize};
 use ssz::four_byte_option_impl;
 use ssz_derive::{Decode, Encode};
-use store::{AnchorInfo, BlobInfo, Split, StoreConfig};
 
 pub use attestation_performance::{
     AttestationPerformance, AttestationPerformanceQuery, AttestationPerformanceStatistics,
 };
-pub use attestation_rewards::StandardAttestationRewards;
 pub use block_packing_efficiency::{
     BlockPackingEfficiency, BlockPackingEfficiencyQuery, ProposerInfo, UniqueAttestation,
 };
 pub use block_rewards::{AttestationRewards, BlockReward, BlockRewardMeta, BlockRewardsQuery};
-pub use lighthouse_network::{types::SyncState, PeerInfo};
-pub use standard_block_rewards::StandardBlockReward;
-pub use sync_committee_rewards::SyncCommitteeReward;
 
 // Define "legacy" implementations of `Option<T>` which use four bytes for encoding the union
 // selector.
 four_byte_option_impl!(four_byte_option_u64, u64);
 four_byte_option_impl!(four_byte_option_hash256, Hash256);
 
-/// Information returned by `peers` and `connected_peers`.
-// TODO: this should be deserializable..
-#[derive(Debug, Clone, Serialize)]
-#[serde(bound = "E: EthSpec")]
-pub struct Peer<E: EthSpec> {
-    /// The Peer's ID
-    pub peer_id: String,
-    /// The PeerInfo associated with the peer.
-    pub peer_info: PeerInfo<E>,
-}
-
 /// The results of validators voting during an epoch.
 ///
 /// Provides information about the current and previous epochs.
@@ -234,15 +218,6 @@ impl From<Eth1Block> for FinalizedExecutionBlock {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct DatabaseInfo {
-    pub schema_version: u64,
-    pub config: StoreConfig,
-    pub split: Split,
-    pub anchor: AnchorInfo,
-    pub blob_info: BlobInfo,
-}
-
 impl BeaconNodeHttpClient {
     /// `GET lighthouse/health`
     pub async fn get_lighthouse_health(&self) -> Result<GenericResponse<Health>, Error> {
@@ -380,19 +355,6 @@ impl BeaconNodeHttpClient {
         self.get_opt::<(), _>(path).await.map(|opt| opt.is_some())
     }
 
-    /// `GET lighthouse/database/info`
-    pub async fn get_lighthouse_database_info(&self) -> Result<DatabaseInfo, Error> {
-        let mut path = self.server.full.clone();
-
-        path.path_segments_mut()
-            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
-            .push("lighthouse")
-            .push("database")
-            .push("info");
-
-        self.get(path).await
-    }
-
     /// `POST lighthouse/database/reconstruct`
     pub async fn post_lighthouse_database_reconstruct(&self) -> Result<String, Error> {
         let mut path = self.server.full.clone();
@@ -406,6 +368,30 @@ impl BeaconNodeHttpClient {
         self.post_with_response(path, &()).await
     }
 
+    /// `POST lighthouse/add_peer`
+    pub async fn post_lighthouse_add_peer(&self, req: AdminPeer) -> Result<(), Error> {
+        let mut path = self.server.full.clone();
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("lighthouse")
+            .push("add_peer");
+
+        self.post_with_response(path, &req).await
+    }
+
+    /// `POST lighthouse/remove_peer`
+    pub async fn post_lighthouse_remove_peer(&self, req: AdminPeer) -> Result<(), Error> {
+        let mut path = self.server.full.clone();
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("lighthouse")
+            .push("remove_peer");
+
+        self.post_with_response(path, &req).await
+    }
+
     /*
      Analysis endpoints.
     */

common/eth2/src/lighthouse/attestation_rewards.rs

@@ -1,55 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_utils::quoted_u64::Quoted;
-
-// Details about the rewards paid for attestations
-// All rewards in GWei
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub struct IdealAttestationRewards {
-    // Validator's effective balance in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub effective_balance: u64,
-    // Ideal attester's reward for head vote in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub head: u64,
-    // Ideal attester's reward for target vote in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub target: u64,
-    // Ideal attester's reward for source vote in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub source: u64,
-    // Ideal attester's inclusion_delay reward in gwei (phase0 only)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub inclusion_delay: Option<Quoted<u64>>,
-    // Ideal attester's inactivity penalty in gwei
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub inactivity: i64,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub struct TotalAttestationRewards {
-    // one entry for every validator based on their attestations in the epoch
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub validator_index: u64,
-    // attester's reward for head vote in gwei
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub head: i64,
-    // attester's reward for target vote in gwei
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub target: i64,
-    // attester's reward for source vote in gwei
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub source: i64,
-    // attester's inclusion_delay reward in gwei (phase0 only)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub inclusion_delay: Option<Quoted<u64>>,
-    // attester's inactivity penalty in gwei
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub inactivity: i64,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub struct StandardAttestationRewards {
-    pub ideal_rewards: Vec<IdealAttestationRewards>,
-    pub total_rewards: Vec<TotalAttestationRewards>,
-}

common/eth2/src/lighthouse/standard_block_rewards.rs

@@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// Details about the rewards for a single block
-// All rewards in GWei
-#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
-pub struct StandardBlockReward {
-    // proposer of the block, the proposer index who receives these rewards
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub proposer_index: u64,
-    // total block reward in gwei,
-    // equal to attestations + sync_aggregate + proposer_slashings + attester_slashings
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub total: u64,
-    // block reward component due to included attestations in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub attestations: u64,
-    // block reward component due to included sync_aggregate in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub sync_aggregate: u64,
-    // block reward component due to included proposer_slashings in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub proposer_slashings: u64,
-    // block reward component due to included attester_slashings in gwei
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub attester_slashings: u64,
-}

common/eth2/src/lighthouse/sync_committee_rewards.rs

@@ -1,13 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// Details about the rewards paid to sync committee members for attesting headers
-// All rewards in GWei
-
-#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
-pub struct SyncCommitteeReward {
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub validator_index: u64,
-    // sync committee reward in gwei for the validator
-    #[serde(with = "serde_utils::quoted_i64")]
-    pub reward: i64,
-}

common/eth2/src/lighthouse/sync_state.rs

@@ -0,0 +1,113 @@
+use serde::{Deserialize, Serialize};
+use types::Slot;
+
+/// The current state of the node.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum SyncState {
+    /// The node is performing a long-range (batch) sync over a finalized chain.
+    /// In this state, parent lookups are disabled.
+    SyncingFinalized { start_slot: Slot, target_slot: Slot },
+    /// The node is performing a long-range (batch) sync over one or many head chains.
+    /// In this state parent lookups are disabled.
+    SyncingHead { start_slot: Slot, target_slot: Slot },
+    /// The node is undertaking a backfill sync. This occurs when a user has specified a trusted
+    /// state. The node first syncs "forward" by downloading blocks up to the current head as
+    /// specified by its peers. Once completed, the node enters this sync state and attempts to
+    /// download all required historical blocks.
+    BackFillSyncing { completed: usize, remaining: usize },
+    /// The node has completed syncing a finalized chain and is in the process of re-evaluating
+    /// which sync state to progress to.
+    SyncTransition,
+    /// The node is up to date with all known peers and is connected to at least one
+    /// fully synced peer. In this state, parent lookups are enabled.
+    Synced,
+    /// No useful peers are connected. Long-range sync's cannot proceed and we have no useful
+    /// peers to download parents for. More peers need to be connected before we can proceed.
+    Stalled,
+}
+
+#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+/// The state of the backfill sync.
+pub enum BackFillState {
+    /// The sync is partially completed and currently paused.
+    Paused,
+    /// We are currently backfilling.
+    Syncing,
+    /// A backfill sync has completed.
+    Completed,
+    /// Too many failed attempts at backfilling. Consider it failed.
+    Failed,
+}
+
+impl PartialEq for SyncState {
+    fn eq(&self, other: &Self) -> bool {
+        matches!(
+            (self, other),
+            (
+                SyncState::SyncingFinalized { .. },
+                SyncState::SyncingFinalized { .. }
+            ) | (SyncState::SyncingHead { .. }, SyncState::SyncingHead { .. })
+                | (SyncState::Synced, SyncState::Synced)
+                | (SyncState::Stalled, SyncState::Stalled)
+                | (SyncState::SyncTransition, SyncState::SyncTransition)
+                | (
+                    SyncState::BackFillSyncing { .. },
+                    SyncState::BackFillSyncing { .. }
+                )
+        )
+    }
+}
+
+impl SyncState {
+    /// Returns a boolean indicating the node is currently performing a long-range sync.
+    pub fn is_syncing(&self) -> bool {
+        match self {
+            SyncState::SyncingFinalized { .. } => true,
+            SyncState::SyncingHead { .. } => true,
+            SyncState::SyncTransition => true,
+            // Backfill doesn't effect any logic, we consider this state, not syncing.
+            SyncState::BackFillSyncing { .. } => false,
+            SyncState::Synced => false,
+            SyncState::Stalled => false,
+        }
+    }
+
+    pub fn is_syncing_finalized(&self) -> bool {
+        match self {
+            SyncState::SyncingFinalized { .. } => true,
+            SyncState::SyncingHead { .. } => false,
+            SyncState::SyncTransition => false,
+            SyncState::BackFillSyncing { .. } => false,
+            SyncState::Synced => false,
+            SyncState::Stalled => false,
+        }
+    }
+
+    /// Returns true if the node is synced.
+    ///
+    /// NOTE: We consider the node synced if it is fetching old historical blocks.
+    pub fn is_synced(&self) -> bool {
+        matches!(self, SyncState::Synced | SyncState::BackFillSyncing { .. })
+    }
+
+    /// Returns true if the node is *stalled*, i.e. has no synced peers.
+    ///
+    /// Usually this state is treated as unsynced, except in some places where we make an exception
+    /// for single-node testnets where having 0 peers is desired.
+    pub fn is_stalled(&self) -> bool {
+        matches!(self, SyncState::Stalled)
+    }
+}
+
+impl std::fmt::Display for SyncState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SyncState::SyncingFinalized { .. } => write!(f, "Syncing Finalized Chain"),
+            SyncState::SyncingHead { .. } => write!(f, "Syncing Head Chain"),
+            SyncState::Synced { .. } => write!(f, "Synced"),
+            SyncState::Stalled { .. } => write!(f, "Stalled"),
+            SyncState::SyncTransition => write!(f, "Evaluating known peers"),
+            SyncState::BackFillSyncing { .. } => write!(f, "Syncing Historical Blocks"),
+        }
+    }
+}

common/eth2/src/types.rs

@@ -5,11 +5,13 @@ use crate::{
     Error as ServerError, CONSENSUS_BLOCK_VALUE_HEADER, CONSENSUS_VERSION_HEADER,
     EXECUTION_PAYLOAD_BLINDED_HEADER, EXECUTION_PAYLOAD_VALUE_HEADER,
 };
-use lighthouse_network::{ConnectionDirection, Enr, Multiaddr, PeerConnectionStatus};
+use enr::{CombinedKey, Enr};
 use mediatype::{names, MediaType, MediaTypeList};
+use multiaddr::Multiaddr;
 use reqwest::header::HeaderMap;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
+use serde_utils::quoted_u64::Quoted;
 use ssz::{Decode, DecodeError};
 use ssz_derive::{Decode, Encode};
 use std::fmt::{self, Display};
@@ -578,7 +580,7 @@ pub struct ChainHeadData {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct IdentityData {
     pub peer_id: String,
-    pub enr: Enr,
+    pub enr: Enr<CombinedKey>,
     pub p2p_addresses: Vec<Multiaddr>,
     pub discovery_addresses: Vec<Multiaddr>,
     pub metadata: MetaData,
@@ -861,19 +863,6 @@ pub enum PeerState {
     Disconnecting,
 }
 
-impl PeerState {
-    pub fn from_peer_connection_status(status: &PeerConnectionStatus) -> Self {
-        match status {
-            PeerConnectionStatus::Connected { .. } => PeerState::Connected,
-            PeerConnectionStatus::Dialing { .. } => PeerState::Connecting,
-            PeerConnectionStatus::Disconnecting { .. } => PeerState::Disconnecting,
-            PeerConnectionStatus::Disconnected { .. }
-            | PeerConnectionStatus::Banned { .. }
-            | PeerConnectionStatus::Unknown => PeerState::Disconnected,
-        }
-    }
-}
-
 impl FromStr for PeerState {
     type Err = String;
 
@@ -906,15 +895,6 @@ pub enum PeerDirection {
     Outbound,
 }
 
-impl PeerDirection {
-    pub fn from_connection_direction(direction: &ConnectionDirection) -> Self {
-        match direction {
-            ConnectionDirection::Incoming => PeerDirection::Inbound,
-            ConnectionDirection::Outgoing => PeerDirection::Outbound,
-        }
-    }
-}
-
 impl FromStr for PeerDirection {
     type Err = String;
 
@@ -1442,6 +1422,18 @@ pub struct StandardLivenessResponseData {
     pub is_live: bool,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ManualFinalizationRequestData {
+    pub state_root: Hash256,
+    pub epoch: Epoch,
+    pub block_root: Hash256,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct AdminPeer {
+    pub enr: String,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct LivenessRequestData {
     pub epoch: Epoch,
@@ -2084,6 +2076,90 @@ pub struct BlobsBundle<E: EthSpec> {
     pub blobs: BlobsList<E>,
 }
 
+/// Details about the rewards paid to sync committee members for attesting headers
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct SyncCommitteeReward {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub validator_index: u64,
+    /// sync committee reward in gwei for the validator
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub reward: i64,
+}
+
+/// Details about the rewards for a single block
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct StandardBlockReward {
+    /// proposer of the block, the proposer index who receives these rewards
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub proposer_index: u64,
+    /// total block reward in gwei,
+    /// equal to attestations + sync_aggregate + proposer_slashings + attester_slashings
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub total: u64,
+    /// block reward component due to included attestations in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub attestations: u64,
+    /// block reward component due to included sync_aggregate in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub sync_aggregate: u64,
+    /// block reward component due to included proposer_slashings in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub proposer_slashings: u64,
+    /// block reward component due to included attester_slashings in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub attester_slashings: u64,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct IdealAttestationRewards {
+    /// Validator's effective balance in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub effective_balance: u64,
+    /// Ideal attester's reward for head vote in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub head: u64,
+    /// Ideal attester's reward for target vote in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub target: u64,
+    /// Ideal attester's reward for source vote in gwei
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub source: u64,
+    /// Ideal attester's inclusion_delay reward in gwei (phase0 only)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub inclusion_delay: Option<Quoted<u64>>,
+    /// Ideal attester's inactivity penalty in gwei
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub inactivity: i64,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct TotalAttestationRewards {
+    /// one entry for every validator based on their attestations in the epoch
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub validator_index: u64,
+    /// attester's reward for head vote in gwei
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub head: i64,
+    /// attester's reward for target vote in gwei
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub target: i64,
+    /// attester's reward for source vote in gwei
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub source: i64,
+    /// attester's inclusion_delay reward in gwei (phase0 only)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub inclusion_delay: Option<Quoted<u64>>,
+    /// attester's inactivity penalty in gwei
+    #[serde(with = "serde_utils::quoted_i64")]
+    pub inactivity: i64,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct StandardAttestationRewards {
+    pub ideal_rewards: Vec<IdealAttestationRewards>,
+    pub total_rewards: Vec<TotalAttestationRewards>,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;