mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-06 18:21:45 +00:00
b6408805a2
* Port eth1 lib to use stable futures * Port eth1_test_rig to stable futures * Port eth1 tests to stable futures * Port genesis service to stable futures * Port genesis tests to stable futures * Port beacon_chain to stable futures * Port lcli to stable futures * Fix eth1_test_rig (#1014) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Update hashmap hashset to stable futures * Adds panic test to hashset delay * Port remote_beacon_node to stable futures * Fix lcli merge conflicts * Non rpc stuff compiles * protocol.rs compiles * Port websockets, timer and notifier to stable futures (#1035) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Port remote_beacon_node to stable futures * Partial eth2-libp2p stable future upgrade * Finished first round of fighting RPC types * Further progress towards porting eth2-libp2p adds caching to discovery * Update behaviour * RPC handler to stable futures * Update RPC to master libp2p * Network service additions * Fix the fallback transport construction (#1102) * Correct warning * Remove hashmap delay * Compiling version of eth2-libp2p * Update all crates versions * Fix conversion function and add tests (#1113) * Port validator_client to stable futures (#1114) * Add PH & MS slot clock changes * Account for genesis time * Add progress on duties refactor * Add simple is_aggregator bool to val subscription * Start work on attestation_verification.rs * Add progress on ObservedAttestations * Progress with ObservedAttestations * Fix tests * Add observed attestations to the beacon chain * Add attestation observation to processing code * Add progress on attestation verification * Add first draft of ObservedAttesters * Add more tests * Add observed attesters to beacon chain * Add observers to attestation processing * Add more attestation verification * Create ObservedAggregators map * Remove commented-out code * Add observed aggregators into chain * Add progress * Finish adding features to attestation verification * Ensure beacon chain compiles * Link attn verification into chain * Integrate new attn verification in chain * Remove old attestation processing code * Start trying to fix beacon_chain tests * Split adding into pools into two functions * Add aggregation to harness * Get test harness working again * Adjust the number of aggregators for test harness * Fix edge-case in harness * Integrate new attn processing in network * Fix compile bug in validator_client * Update validator API endpoints * Fix aggreagation in test harness * Fix enum thing * Fix attestation observation bug: * Patch failing API tests * Start adding comments to attestation verification * Remove unused attestation field * Unify "is block known" logic * Update comments * Supress fork choice errors for network processing * Add todos * Tidy * Add gossip attn tests * Disallow test harness to produce old attns * Comment out in-progress tests * Partially address pruning tests * Fix failing store test * Add aggregate tests * Add comments about which spec conditions we check * Dont re-aggregate * Split apart test harness attn production * Fix compile error in network * Make progress on commented-out test * Fix skipping attestation test * Add fork choice verification tests * Tidy attn tests, remove dead code * Remove some accidentally added code * Fix clippy lint * Rename test file * Add block tests, add cheap block proposer check * Rename block testing file * Add observed_block_producers * Tidy * Switch around block signature verification * Finish block testing * Remove gossip from signature tests * First pass of self review * Fix deviation in spec * Update test spec tags * Start moving over to hashset * Finish moving observed attesters to hashmap * Move aggregation pool over to hashmap * Make fc attn borrow again * Fix rest_api compile error * Fix missing comments * Fix monster test * Uncomment increasing slots test * Address remaining comments * Remove unsafe, use cfg test * Remove cfg test flag * Fix dodgy comment * Revert "Update hashmap hashset to stable futures" This reverts commitd432378a3c. * Revert "Adds panic test to hashset delay" This reverts commit281502396f. * Ported attestation_service * Ported duties_service * Ported fork_service * More ports * Port block_service * Minor fixes * VC compiles * Update TODOS * Borrow self where possible * Ignore aggregates that are already known. * Unify aggregator modulo logic * Fix typo in logs * Refactor validator subscription logic * Avoid reproducing selection proof * Skip HTTP call if no subscriptions * Rename DutyAndState -> DutyAndProof * Tidy logs * Print root as dbg * Fix compile errors in tests * Fix compile error in test * Re-Fix attestation and duties service * Minor fixes Co-authored-by: Paul Hauner <paul@paulhauner.com> * Network crate update to stable futures * Port account_manager to stable futures (#1121) * Port account_manager to stable futures * Run async fns in tokio environment * Port rest_api crate to stable futures (#1118) * Port rest_api lib to stable futures * Reduce tokio features * Update notifier to stable futures * Builder update * Further updates * Convert self referential async functions * stable futures fixes (#1124) * Fix eth1 update functions * Fix genesis and client * Fix beacon node lib * Return appropriate runtimes from environment * Fix test rig * Refactor eth1 service update * Upgrade simulator to stable futures * Lighthouse compiles on stable futures * Remove println debugging statement * Update libp2p service, start rpc test upgrade * Update network crate for new libp2p * Update tokio::codec to futures_codec (#1128) * Further work towards RPC corrections * Correct http timeout and network service select * Use tokio runtime for libp2p * Revert "Update tokio::codec to futures_codec (#1128)" This reverts commite57aea924a. * Upgrade RPC libp2p tests * Upgrade secio fallback test * Upgrade gossipsub examples * Clean up RPC protocol * Test fixes (#1133) * Correct websocket timeout and run on os thread * Fix network test * Clean up PR * Correct tokio tcp move attestation service tests * Upgrade attestation service tests * Correct network test * Correct genesis test * Test corrections * Log info when block is received * Modify logs and update attester service events * Stable futures: fixes to vc, eth1 and account manager (#1142) * Add local testnet scripts * Remove whiteblock script * Rename local testnet script * Move spawns onto handle * Fix VC panic * Initial fix to block production issue * Tidy block producer fix * Tidy further * Add local testnet clean script * Run cargo fmt * Tidy duties service * Tidy fork service * Tidy ForkService * Tidy AttestationService * Tidy notifier * Ensure await is not suppressed in eth1 * Ensure await is not suppressed in account_manager * Use .ok() instead of .unwrap_or(()) * RPC decoding test for proto * Update discv5 and eth2-libp2p deps * Fix lcli double runtime issue (#1144) * Handle stream termination and dialing peer errors * Correct peer_info variant types * Remove unnecessary warnings * Handle subnet unsubscription removal and improve logigng * Add logs around ping * Upgrade discv5 and improve logging * Handle peer connection status for multiple connections * Improve network service logging * Improve logging around peer manager * Upgrade swarm poll centralise peer management * Identify clients on error * Fix `remove_peer` in sync (#1150) * remove_peer removes from all chains * Remove logs * Fix early return from loop * Improved logging, fix panic * Partially correct tests * Stable futures: Vc sync (#1149) * Improve syncing heuristic * Add comments * Use safer method for tolerance * Fix tests * Stable futures: Fix VC bug, update agg pool, add more metrics (#1151) * Expose epoch processing summary * Expose participation metrics to prometheus * Switch to f64 * Reduce precision * Change precision * Expose observed attesters metrics * Add metrics for agg/unagg attn counts * Add metrics for gossip rx * Add metrics for gossip tx * Adds ignored attns to prom * Add attestation timing * Add timer for aggregation pool sig agg * Add write lock timer for agg pool * Add more metrics to agg pool * Change map lock code * Add extra metric to agg pool * Change lock handling in agg pool * Change .write() to .read() * Add another agg pool timer * Fix for is_aggregator * Fix pruning bug Co-authored-by: pawan <pawandhananjay@gmail.com> Co-authored-by: Paul Hauner <paul@paulhauner.com>
527 lines
18 KiB
Rust
527 lines
18 KiB
Rust
use crate::helpers::*;
|
|
use crate::response_builder::ResponseBuilder;
|
|
use crate::validator::get_state_for_epoch;
|
|
use crate::{ApiError, ApiResult, UrlQuery};
|
|
use beacon_chain::{BeaconChain, BeaconChainTypes, StateSkipConfig};
|
|
use hyper::{Body, Request};
|
|
use rest_types::{
|
|
BlockResponse, CanonicalHeadResponse, Committee, HeadBeaconBlock, StateResponse,
|
|
ValidatorRequest, ValidatorResponse,
|
|
};
|
|
use std::sync::Arc;
|
|
use store::Store;
|
|
use types::{
|
|
AttesterSlashing, BeaconState, EthSpec, Hash256, ProposerSlashing, PublicKeyBytes,
|
|
RelativeEpoch, Slot,
|
|
};
|
|
|
|
/// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
|
|
pub fn get_head<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let chain_head = beacon_chain.head()?;
|
|
|
|
let head = CanonicalHeadResponse {
|
|
slot: chain_head.beacon_state.slot,
|
|
block_root: chain_head.beacon_block_root,
|
|
state_root: chain_head.beacon_state_root,
|
|
finalized_slot: chain_head
|
|
.beacon_state
|
|
.finalized_checkpoint
|
|
.epoch
|
|
.start_slot(T::EthSpec::slots_per_epoch()),
|
|
finalized_block_root: chain_head.beacon_state.finalized_checkpoint.root,
|
|
justified_slot: chain_head
|
|
.beacon_state
|
|
.current_justified_checkpoint
|
|
.epoch
|
|
.start_slot(T::EthSpec::slots_per_epoch()),
|
|
justified_block_root: chain_head.beacon_state.current_justified_checkpoint.root,
|
|
previous_justified_slot: chain_head
|
|
.beacon_state
|
|
.previous_justified_checkpoint
|
|
.epoch
|
|
.start_slot(T::EthSpec::slots_per_epoch()),
|
|
previous_justified_block_root: chain_head.beacon_state.previous_justified_checkpoint.root,
|
|
};
|
|
|
|
ResponseBuilder::new(&req)?.body(&head)
|
|
}
|
|
|
|
/// HTTP handler to return a list of head BeaconBlocks.
|
|
pub fn get_heads<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let heads = beacon_chain
|
|
.heads()
|
|
.into_iter()
|
|
.map(|(beacon_block_root, beacon_block_slot)| HeadBeaconBlock {
|
|
beacon_block_root,
|
|
beacon_block_slot,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
ResponseBuilder::new(&req)?.body(&heads)
|
|
}
|
|
|
|
/// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
|
|
pub fn get_block<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let query_params = ["root", "slot"];
|
|
let (key, value) = UrlQuery::from_request(&req)?.first_of(&query_params)?;
|
|
|
|
let block_root = match (key.as_ref(), value) {
|
|
("slot", value) => {
|
|
let target = parse_slot(&value)?;
|
|
|
|
block_root_at_slot(&beacon_chain, target)?.ok_or_else(|| {
|
|
ApiError::NotFound(format!(
|
|
"Unable to find SignedBeaconBlock for slot {:?}",
|
|
target
|
|
))
|
|
})?
|
|
}
|
|
("root", value) => parse_root(&value)?,
|
|
_ => return Err(ApiError::ServerError("Unexpected query parameter".into())),
|
|
};
|
|
|
|
let block = beacon_chain.store.get_block(&block_root)?.ok_or_else(|| {
|
|
ApiError::NotFound(format!(
|
|
"Unable to find SignedBeaconBlock for root {:?}",
|
|
block_root
|
|
))
|
|
})?;
|
|
|
|
let response = BlockResponse {
|
|
root: block_root,
|
|
beacon_block: block,
|
|
};
|
|
|
|
ResponseBuilder::new(&req)?.body(&response)
|
|
}
|
|
|
|
/// HTTP handler to return a `SignedBeaconBlock` root at a given `slot`.
|
|
pub fn get_block_root<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let slot_string = UrlQuery::from_request(&req)?.only_one("slot")?;
|
|
let target = parse_slot(&slot_string)?;
|
|
|
|
let root = block_root_at_slot(&beacon_chain, target)?.ok_or_else(|| {
|
|
ApiError::NotFound(format!(
|
|
"Unable to find SignedBeaconBlock for slot {:?}",
|
|
target
|
|
))
|
|
})?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&root)
|
|
}
|
|
|
|
/// HTTP handler to return the `Fork` of the current head.
|
|
pub fn get_fork<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
ResponseBuilder::new(&req)?.body(&beacon_chain.head()?.beacon_state.fork)
|
|
}
|
|
|
|
/// HTTP handler to which accepts a query string of a list of validator pubkeys and maps it to a
|
|
/// `ValidatorResponse`.
|
|
///
|
|
/// This method is limited to as many `pubkeys` that can fit in a URL. See `post_validators` for
|
|
/// doing bulk requests.
|
|
pub fn get_validators<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let query = UrlQuery::from_request(&req)?;
|
|
|
|
let validator_pubkeys = query
|
|
.all_of("validator_pubkeys")?
|
|
.iter()
|
|
.map(|validator_pubkey_str| parse_pubkey_bytes(validator_pubkey_str))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
let state_root_opt = if let Some((_key, value)) = query.first_of_opt(&["state_root"]) {
|
|
Some(parse_root(&value)?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let validators =
|
|
validator_responses_by_pubkey(beacon_chain, state_root_opt, validator_pubkeys)?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&validators)
|
|
}
|
|
|
|
/// HTTP handler to return all validators, each as a `ValidatorResponse`.
|
|
pub fn get_all_validators<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let query = UrlQuery::from_request(&req)?;
|
|
|
|
let state_root_opt = if let Some((_key, value)) = query.first_of_opt(&["state_root"]) {
|
|
Some(parse_root(&value)?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
|
|
state.update_pubkey_cache()?;
|
|
|
|
let validators = state
|
|
.validators
|
|
.iter()
|
|
.map(|validator| validator_response_by_pubkey(&state, validator.pubkey.clone()))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&validators)
|
|
}
|
|
|
|
/// HTTP handler to return all active validators, each as a `ValidatorResponse`.
|
|
pub fn get_active_validators<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let query = UrlQuery::from_request(&req)?;
|
|
|
|
let state_root_opt = if let Some((_key, value)) = query.first_of_opt(&["state_root"]) {
|
|
Some(parse_root(&value)?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
|
|
state.update_pubkey_cache()?;
|
|
|
|
let validators = state
|
|
.validators
|
|
.iter()
|
|
.filter(|validator| validator.is_active_at(state.current_epoch()))
|
|
.map(|validator| validator_response_by_pubkey(&state, validator.pubkey.clone()))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&validators)
|
|
}
|
|
|
|
/// HTTP handler to which accepts a `ValidatorRequest` and returns a `ValidatorResponse` for
|
|
/// each of the given `pubkeys`. When `state_root` is `None`, the canonical head is used.
|
|
///
|
|
/// This method allows for a basically unbounded list of `pubkeys`, where as the `get_validators`
|
|
/// request is limited by the max number of pubkeys you can fit in a URL.
|
|
pub async fn post_validators<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let response_builder = ResponseBuilder::new(&req);
|
|
|
|
let body = req.into_body();
|
|
let chunks = hyper::body::to_bytes(body)
|
|
.await
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
|
|
serde_json::from_slice::<ValidatorRequest>(&chunks)
|
|
.map_err(|e| {
|
|
ApiError::BadRequest(format!(
|
|
"Unable to parse JSON into ValidatorRequest: {:?}",
|
|
e
|
|
))
|
|
})
|
|
.and_then(|bulk_request| {
|
|
validator_responses_by_pubkey(
|
|
beacon_chain,
|
|
bulk_request.state_root,
|
|
bulk_request.pubkeys,
|
|
)
|
|
})
|
|
.and_then(|validators| response_builder?.body(&validators))
|
|
}
|
|
|
|
/// Returns either the state given by `state_root_opt`, or the canonical head state if it is
|
|
/// `None`.
|
|
fn get_state_from_root_opt<T: BeaconChainTypes>(
|
|
beacon_chain: &BeaconChain<T>,
|
|
state_root_opt: Option<Hash256>,
|
|
) -> Result<BeaconState<T::EthSpec>, ApiError> {
|
|
if let Some(state_root) = state_root_opt {
|
|
beacon_chain
|
|
.get_state(&state_root, None)
|
|
.map_err(|e| {
|
|
ApiError::ServerError(format!(
|
|
"Database error when reading state root {}: {:?}",
|
|
state_root, e
|
|
))
|
|
})?
|
|
.ok_or_else(|| ApiError::NotFound(format!("No state exists with root: {}", state_root)))
|
|
} else {
|
|
Ok(beacon_chain.head()?.beacon_state)
|
|
}
|
|
}
|
|
|
|
/// Maps a vec of `validator_pubkey` to a vec of `ValidatorResponse`, using the state at the given
|
|
/// `state_root`. If `state_root.is_none()`, uses the canonial head state.
|
|
fn validator_responses_by_pubkey<T: BeaconChainTypes>(
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
state_root_opt: Option<Hash256>,
|
|
validator_pubkeys: Vec<PublicKeyBytes>,
|
|
) -> Result<Vec<ValidatorResponse>, ApiError> {
|
|
let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
|
|
state.update_pubkey_cache()?;
|
|
|
|
validator_pubkeys
|
|
.into_iter()
|
|
.map(|validator_pubkey| validator_response_by_pubkey(&state, validator_pubkey))
|
|
.collect::<Result<Vec<_>, ApiError>>()
|
|
}
|
|
|
|
/// Maps a `validator_pubkey` to a `ValidatorResponse`, using the given state.
|
|
///
|
|
/// The provided `state` must have a fully up-to-date pubkey cache.
|
|
fn validator_response_by_pubkey<E: EthSpec>(
|
|
state: &BeaconState<E>,
|
|
validator_pubkey: PublicKeyBytes,
|
|
) -> Result<ValidatorResponse, ApiError> {
|
|
let validator_index_opt = state
|
|
.get_validator_index(&validator_pubkey)
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to read pubkey cache: {:?}", e)))?;
|
|
|
|
if let Some(validator_index) = validator_index_opt {
|
|
let balance = state.balances.get(validator_index).ok_or_else(|| {
|
|
ApiError::ServerError(format!("Invalid balances index: {:?}", validator_index))
|
|
})?;
|
|
|
|
let validator = state
|
|
.validators
|
|
.get(validator_index)
|
|
.ok_or_else(|| {
|
|
ApiError::ServerError(format!("Invalid validator index: {:?}", validator_index))
|
|
})?
|
|
.clone();
|
|
|
|
Ok(ValidatorResponse {
|
|
pubkey: validator_pubkey,
|
|
validator_index: Some(validator_index),
|
|
balance: Some(*balance),
|
|
validator: Some(validator),
|
|
})
|
|
} else {
|
|
Ok(ValidatorResponse {
|
|
pubkey: validator_pubkey,
|
|
validator_index: None,
|
|
balance: None,
|
|
validator: None,
|
|
})
|
|
}
|
|
}
|
|
|
|
/// HTTP handler
|
|
pub fn get_committees<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let query = UrlQuery::from_request(&req)?;
|
|
|
|
let epoch = query.epoch()?;
|
|
|
|
let mut state = get_state_for_epoch(&beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;
|
|
|
|
let relative_epoch = RelativeEpoch::from_epoch(state.current_epoch(), epoch).map_err(|e| {
|
|
ApiError::ServerError(format!("Failed to get state suitable for epoch: {:?}", e))
|
|
})?;
|
|
|
|
state
|
|
.build_committee_cache(relative_epoch, &beacon_chain.spec)
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to build committee cache: {:?}", e)))?;
|
|
|
|
let committees = state
|
|
.get_beacon_committees_at_epoch(relative_epoch)
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to get all committees: {:?}", e)))?
|
|
.into_iter()
|
|
.map(|c| Committee {
|
|
slot: c.slot,
|
|
index: c.index,
|
|
committee: c.committee.to_vec(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
ResponseBuilder::new(&req)?.body(&committees)
|
|
}
|
|
|
|
/// HTTP handler to return a `BeaconState` at a given `root` or `slot`.
|
|
///
|
|
/// Will not return a state if the request slot is in the future. Will return states higher than
|
|
/// the current head by skipping slots.
|
|
pub fn get_state<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let head_state = beacon_chain.head()?.beacon_state;
|
|
|
|
let (key, value) = match UrlQuery::from_request(&req) {
|
|
Ok(query) => {
|
|
// We have *some* parameters, just check them.
|
|
let query_params = ["root", "slot"];
|
|
query.first_of(&query_params)?
|
|
}
|
|
Err(ApiError::BadRequest(_)) => {
|
|
// No parameters provided at all, use current slot.
|
|
(String::from("slot"), head_state.slot.to_string())
|
|
}
|
|
Err(e) => {
|
|
return Err(e);
|
|
}
|
|
};
|
|
|
|
let (root, state): (Hash256, BeaconState<T::EthSpec>) = match (key.as_ref(), value) {
|
|
("slot", value) => state_at_slot(&beacon_chain, parse_slot(&value)?)?,
|
|
("root", value) => {
|
|
let root = &parse_root(&value)?;
|
|
|
|
let state = beacon_chain
|
|
.store
|
|
.get_state(root, None)?
|
|
.ok_or_else(|| ApiError::NotFound(format!("No state for root: {:?}", root)))?;
|
|
|
|
(*root, state)
|
|
}
|
|
_ => return Err(ApiError::ServerError("Unexpected query parameter".into())),
|
|
};
|
|
|
|
let response = StateResponse {
|
|
root,
|
|
beacon_state: state,
|
|
};
|
|
|
|
ResponseBuilder::new(&req)?.body(&response)
|
|
}
|
|
|
|
/// HTTP handler to return a `BeaconState` root at a given `slot`.
|
|
///
|
|
/// Will not return a state if the request slot is in the future. Will return states higher than
|
|
/// the current head by skipping slots.
|
|
pub fn get_state_root<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let slot_string = UrlQuery::from_request(&req)?.only_one("slot")?;
|
|
let slot = parse_slot(&slot_string)?;
|
|
|
|
let root = state_root_at_slot(&beacon_chain, slot, StateSkipConfig::WithStateRoots)?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&root)
|
|
}
|
|
|
|
/// HTTP handler to return a `BeaconState` at the genesis block.
|
|
///
|
|
/// This is an undocumented convenience method used during testing. For production, simply do a
|
|
/// state request at slot 0.
|
|
pub fn get_genesis_state<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let (_root, state) = state_at_slot(&beacon_chain, Slot::new(0))?;
|
|
|
|
ResponseBuilder::new(&req)?.body(&state)
|
|
}
|
|
|
|
/// Read the genesis time from the current beacon chain state.
|
|
pub fn get_genesis_time<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_time)
|
|
}
|
|
|
|
/// Read the `genesis_validators_root` from the current beacon chain state.
|
|
pub fn get_genesis_validators_root<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_validators_root)
|
|
}
|
|
|
|
pub async fn proposer_slashing<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let response_builder = ResponseBuilder::new(&req);
|
|
|
|
let body = req.into_body();
|
|
let chunks = hyper::body::to_bytes(body)
|
|
.await
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
|
|
|
|
serde_json::from_slice::<ProposerSlashing>(&chunks)
|
|
.map_err(|e| {
|
|
ApiError::BadRequest(format!(
|
|
"Unable to parse JSON into ProposerSlashing: {:?}",
|
|
e
|
|
))
|
|
})
|
|
.and_then(move |proposer_slashing| {
|
|
let spec = &beacon_chain.spec;
|
|
let state = &beacon_chain.head().unwrap().beacon_state;
|
|
if beacon_chain.eth1_chain.is_some() {
|
|
beacon_chain
|
|
.op_pool
|
|
.insert_proposer_slashing(proposer_slashing, state, spec)
|
|
.map_err(|e| {
|
|
ApiError::BadRequest(format!(
|
|
"Error while inserting proposer slashing: {:?}",
|
|
e
|
|
))
|
|
})
|
|
} else {
|
|
return Err(ApiError::BadRequest(
|
|
"Cannot insert proposer slashing on node without Eth1 connection.".to_string(),
|
|
));
|
|
}
|
|
})
|
|
.and_then(|_| response_builder?.body(&true))
|
|
}
|
|
|
|
pub async fn attester_slashing<T: BeaconChainTypes>(
|
|
req: Request<Body>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
) -> ApiResult {
|
|
let response_builder = ResponseBuilder::new(&req);
|
|
|
|
let body = req.into_body();
|
|
let chunks = hyper::body::to_bytes(body)
|
|
.await
|
|
.map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
|
|
|
|
serde_json::from_slice::<AttesterSlashing<T::EthSpec>>(&chunks)
|
|
.map_err(|e| {
|
|
ApiError::BadRequest(format!(
|
|
"Unable to parse JSON into AttesterSlashing: {:?}",
|
|
e
|
|
))
|
|
})
|
|
.and_then(move |attester_slashing| {
|
|
let spec = &beacon_chain.spec;
|
|
let state = &beacon_chain.head().unwrap().beacon_state;
|
|
if beacon_chain.eth1_chain.is_some() {
|
|
beacon_chain
|
|
.op_pool
|
|
.insert_attester_slashing(attester_slashing, state, spec)
|
|
.map_err(|e| {
|
|
ApiError::BadRequest(format!(
|
|
"Error while inserting attester slashing: {:?}",
|
|
e
|
|
))
|
|
})
|
|
} else {
|
|
Err(ApiError::BadRequest(
|
|
"Cannot insert attester slashing on node without Eth1 connection.".to_string(),
|
|
))
|
|
}
|
|
})
|
|
.and_then(|_| response_builder?.body(&true))
|
|
}
|