95c8e476bc
* Remove ping protocol * Initial renaming of network services * Correct rebasing relative to latest master * Start updating types * Adds HashMapDelay struct to utils * Initial network restructure * Network restructure. Adds new types for v0.2.0 * Removes build artefacts * Shift validation to beacon chain * Temporarily remove gossip validation This is to be updated to match current optimisation efforts. * Adds AggregateAndProof * Begin rebuilding pubsub encoding/decoding * Signature hacking * Shift gossipsup decoding into eth2_libp2p * Existing EF tests passing with fake_crypto * Shifts block encoding/decoding into RPC * Delete outdated API spec * All release tests passing bar genesis state parsing * Update and test YamlConfig * Update to spec v0.10 compatible BLS * Updates to BLS EF tests * Add EF test for AggregateVerify And delete unused hash2curve tests for uncompressed points * Update EF tests to v0.10.1 * Use optional block root correctly in block proc * Use genesis fork in deposit domain. All tests pass * Fast aggregate verify test * Update REST API docs * Fix unused import * Bump spec tags to v0.10.1 * Add `seconds_per_eth1_block` to chainspec * Update to timestamp based eth1 voting scheme * Return None from `get_votes_to_consider` if block cache is empty * Handle overflows in `is_candidate_block` * Revert to failing tests * Fix eth1 data sets test * Choose default vote according to spec * Fix collect_valid_votes tests * Fix `get_votes_to_consider` to choose all eligible blocks * Uncomment winning_vote tests * Add comments; remove unused code * Reduce seconds_per_eth1_block for simulation * Addressed review comments * Add test for default vote case * Fix logs * Remove unused functions * Meter default eth1 votes * Fix comments * Progress on attestation service * Address review comments; remove unused dependency * Initial work on removing libp2p lock * Add LRU caches to store (rollup) * Update attestation validation for DB changes (WIP) * Initial version of should_forward_block * Scaffold * Progress on attestation validation Also, consolidate prod+testing slot clocks so that they share much of the same implementation and can both handle sub-slot time changes. * Removes lock from libp2p service * Completed network lock removal * Finish(?) attestation processing * Correct network termination future * Add slot check to block check * Correct fmt issues * Remove Drop implementation for network service * Add first attempt at attestation proc. re-write * Add version 2 of attestation processing * Minor fixes * Add validator pubkey cache * Make get_indexed_attestation take a committee * Link signature processing into new attn verification * First working version * Ensure pubkey cache is updated * Add more metrics, slight optimizations * Clone committee cache during attestation processing * Update shuffling cache during block processing * Remove old commented-out code * Fix shuffling cache insert bug * Used indexed attestation in fork choice * Restructure attn processing, add metrics * Add more detailed metrics * Tidy, fix failing tests * Fix failing tests, tidy * Address reviewers suggestions * Disable/delete two outdated tests * Modification of validator for subscriptions * Add slot signing to validator client * Further progress on validation subscription * Adds necessary validator subscription functionality * Add new Pubkeys struct to signature_sets * Refactor with functional approach * Update beacon chain * Clean up validator <-> beacon node http types * Add aggregator status to ValidatorDuty * Impl Clone for manual slot clock * Fix minor errors * Further progress validator client subscription * Initial subscription and aggregation handling * Remove decompressed member from pubkey bytes * Progress to modifying val client for attestation aggregation * First draft of validator client upgrade for aggregate attestations * Add hashmap for indices lookup * Add state cache, remove store cache * Only build the head committee cache * Removes lock on a network channel * Partially implement beacon node subscription http api * Correct compilation issues * Change `get_attesting_indices` to use Vec * Fix failing test * Partial implementation of timer * Adds timer, removes exit_future, http api to op pool * Partial multiple aggregate attestation handling * Permits bulk messages accross gossipsub network channel * Correct compile issues * Improve gosispsub messaging and correct rest api helpers * Added global gossipsub subscriptions * Update validator subscriptions data structs * Tidy * Re-structure validator subscriptions * Initial handling of subscriptions * Re-structure network service * Add pubkey cache persistence file * Add more comments * Integrate persistence file into builder * Add pubkey cache tests * Add HashSetDelay and introduce into attestation service * Handles validator subscriptions * Add data_dir to beacon chain builder * Remove Option in pubkey cache persistence file * Ensure consistency between datadir/data_dir * Fix failing network test * Peer subnet discovery gets queued for future subscriptions * Reorganise attestation service functions * Initial wiring of attestation service * First draft of attestation service timing logic * Correct minor typos * Tidy * Fix todos * Improve tests * Add PeerInfo to connected peers mapping * Fix compile error * Fix compile error from merge * Split up block processing metrics * Tidy * Refactor get_pubkey_from_state * Remove commented-out code * Rename state_cache -> checkpoint_cache * Rename Checkpoint -> Snapshot * Tidy, add comments * Tidy up find_head function * Change some checkpoint -> snapshot * Add tests * Expose max_len * Remove dead code * Tidy * Fix bug * Add sync-speed metric * Add first attempt at VerifiableBlock * Start integrating into beacon chain * Integrate VerifiableBlock * Rename VerifableBlock -> PartialBlockVerification * Add start of typed methods * Add progress * Add further progress * Rename structs * Add full block verification to block_processing.rs * Further beacon chain integration * Update checks for gossip * Add todo * Start adding segement verification * Add passing chain segement test * Initial integration with batch sync * Minor changes * Tidy, add more error checking * Start adding chain_segment tests * Finish invalid signature tests * Include single and gossip verified blocks in tests * Add gossip verification tests * Start adding docs * Finish adding comments to block_processing.rs * Rename block_processing.rs -> block_verification * Start removing old block processing code * Fixes beacon_chain compilation * Fix project-wide compile errors * Remove old code * Correct code to pass all tests * Fix bug with beacon proposer index * Fix shim for BlockProcessingError * Only process one epoch at a time * Fix loop in chain segment processing * Correct tests from master merge * Add caching for state.eth1_data_votes * Add BeaconChain::validator_pubkey * Revert "Add caching for state.eth1_data_votes" This reverts commit cd73dcd6434fb8d8e6bf30c5356355598ea7b78e. Co-authored-by: Grant Wuerker <gwuerker@gmail.com> Co-authored-by: Michael Sproul <michael@sigmaprime.io> Co-authored-by: Michael Sproul <micsproul@gmail.com> Co-authored-by: pawan <pawandhananjay@gmail.com> Co-authored-by: Paul Hauner <paul@paulhauner.com>
1026 lines
30 KiB
Rust
1026 lines
30 KiB
Rust
#![cfg(test)]
|
|
|
|
use beacon_chain::{BeaconChain, BeaconChainTypes, StateSkipConfig};
|
|
use node_test_rig::{
|
|
environment::{Environment, EnvironmentBuilder},
|
|
testing_client_config, ClientConfig, ClientGenesis, LocalBeaconNode,
|
|
};
|
|
use remote_beacon_node::{
|
|
Committee, HeadBeaconBlock, PersistedOperationPool, PublishStatus, ValidatorResponse,
|
|
};
|
|
use rest_types::ValidatorDutyBytes;
|
|
use std::convert::TryInto;
|
|
use std::sync::Arc;
|
|
use types::{
|
|
test_utils::{
|
|
build_double_vote_attester_slashing, build_proposer_slashing,
|
|
generate_deterministic_keypair, AttesterSlashingTestTask, ProposerSlashingTestTask,
|
|
},
|
|
BeaconBlock, BeaconState, ChainSpec, Domain, Epoch, EthSpec, MinimalEthSpec, PublicKey,
|
|
RelativeEpoch, Signature, SignedBeaconBlock, SignedRoot, Slot, Validator,
|
|
};
|
|
use version;
|
|
|
|
type E = MinimalEthSpec;
|
|
|
|
fn build_env() -> Environment<E> {
|
|
EnvironmentBuilder::minimal()
|
|
.null_logger()
|
|
.expect("should build env logger")
|
|
.single_thread_tokio_runtime()
|
|
.expect("should start tokio runtime")
|
|
.build()
|
|
.expect("environment should build")
|
|
}
|
|
|
|
fn build_node<E: EthSpec>(env: &mut Environment<E>, config: ClientConfig) -> LocalBeaconNode<E> {
|
|
let context = env.core_context();
|
|
env.runtime()
|
|
.block_on(LocalBeaconNode::production(context, config))
|
|
.expect("should block until node created")
|
|
}
|
|
|
|
/// Returns the randao reveal for the given slot (assuming the given `beacon_chain` uses
|
|
/// deterministic keypairs).
|
|
fn get_randao_reveal<T: BeaconChainTypes>(
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
slot: Slot,
|
|
spec: &ChainSpec,
|
|
) -> Signature {
|
|
let fork = beacon_chain
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.fork;
|
|
let proposer_index = beacon_chain
|
|
.block_proposer(slot)
|
|
.expect("should get proposer index");
|
|
let keypair = generate_deterministic_keypair(proposer_index);
|
|
let epoch = slot.epoch(E::slots_per_epoch());
|
|
let domain = spec.get_domain(epoch, Domain::Randao, &fork);
|
|
let message = epoch.signing_root(domain);
|
|
Signature::new(message.as_bytes(), &keypair.sk)
|
|
}
|
|
|
|
/// Signs the given block (assuming the given `beacon_chain` uses deterministic keypairs).
|
|
fn sign_block<T: BeaconChainTypes>(
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
block: BeaconBlock<T::EthSpec>,
|
|
spec: &ChainSpec,
|
|
) -> SignedBeaconBlock<T::EthSpec> {
|
|
let fork = beacon_chain
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.fork;
|
|
let proposer_index = beacon_chain
|
|
.block_proposer(block.slot)
|
|
.expect("should get proposer index");
|
|
let keypair = generate_deterministic_keypair(proposer_index);
|
|
block.sign(&keypair.sk, &fork, spec)
|
|
}
|
|
|
|
#[test]
|
|
fn validator_produce_attestation() {
|
|
let mut env = build_env();
|
|
|
|
let spec = &E::default_spec();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let beacon_chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain");
|
|
let state = beacon_chain.head().expect("should get head").beacon_state;
|
|
|
|
let validator_index = 0;
|
|
let duties = state
|
|
.get_attestation_duties(validator_index, RelativeEpoch::Current)
|
|
.expect("should have attestation duties cache")
|
|
.expect("should have attestation duties");
|
|
|
|
let mut attestation = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.validator()
|
|
.produce_attestation(duties.slot, duties.index),
|
|
)
|
|
.expect("should fetch attestation from http api");
|
|
|
|
assert_eq!(
|
|
attestation.data.index, duties.index,
|
|
"should have same index"
|
|
);
|
|
assert_eq!(attestation.data.slot, duties.slot, "should have same slot");
|
|
assert_eq!(
|
|
attestation.aggregation_bits.num_set_bits(),
|
|
0,
|
|
"should have empty aggregation bits"
|
|
);
|
|
|
|
let keypair = generate_deterministic_keypair(validator_index);
|
|
|
|
// Fetch the duties again, but via HTTP for authenticity.
|
|
let duties = env
|
|
.runtime()
|
|
.block_on(remote_node.http.validator().get_duties(
|
|
attestation.data.slot.epoch(E::slots_per_epoch()),
|
|
&[keypair.pk.clone()],
|
|
))
|
|
.expect("should fetch duties from http api");
|
|
let duties = &duties[0];
|
|
|
|
// Try publishing the attestation without a signature, ensure it is flagged as invalid.
|
|
let publish_status = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.validator()
|
|
.publish_attestations(vec![attestation.clone()]),
|
|
)
|
|
.expect("should publish attestation");
|
|
assert!(
|
|
!publish_status.is_valid(),
|
|
"the unsigned published attestation should not be valid"
|
|
);
|
|
|
|
attestation
|
|
.sign(
|
|
&keypair.sk,
|
|
duties
|
|
.attestation_committee_position
|
|
.expect("should have committee position"),
|
|
&state.fork,
|
|
spec,
|
|
)
|
|
.expect("should sign attestation");
|
|
|
|
// Try publishing the valid attestation.
|
|
let publish_status = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.validator()
|
|
.publish_attestations(vec![attestation]),
|
|
)
|
|
.expect("should publish attestation");
|
|
assert!(
|
|
publish_status.is_valid(),
|
|
"the signed published attestation should be valid"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn validator_duties() {
|
|
let mut env = build_env();
|
|
|
|
let spec = &E::default_spec();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let beacon_chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain");
|
|
|
|
let mut epoch = Epoch::new(0);
|
|
|
|
let validators = beacon_chain
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.validators
|
|
.iter()
|
|
.map(|v| (&v.pubkey).try_into().expect("pubkey should be valid"))
|
|
.collect::<Vec<_>>();
|
|
|
|
let duties = env
|
|
.runtime()
|
|
.block_on(remote_node.http.validator().get_duties(epoch, &validators))
|
|
.expect("should fetch duties from http api");
|
|
|
|
// 1. Check at the current epoch.
|
|
check_duties(
|
|
duties,
|
|
epoch,
|
|
validators.clone(),
|
|
beacon_chain.clone(),
|
|
spec,
|
|
);
|
|
|
|
epoch += 4;
|
|
let duties = env
|
|
.runtime()
|
|
.block_on(remote_node.http.validator().get_duties(epoch, &validators))
|
|
.expect("should fetch duties from http api");
|
|
|
|
// 2. Check with a long skip forward.
|
|
check_duties(duties, epoch, validators, beacon_chain, spec);
|
|
|
|
// TODO: test an epoch in the past. Blocked because the `LocalBeaconNode` cannot produce a
|
|
// chain, yet.
|
|
}
|
|
|
|
fn check_duties<T: BeaconChainTypes>(
|
|
duties: Vec<ValidatorDutyBytes>,
|
|
epoch: Epoch,
|
|
validators: Vec<PublicKey>,
|
|
beacon_chain: Arc<BeaconChain<T>>,
|
|
spec: &ChainSpec,
|
|
) {
|
|
assert_eq!(
|
|
validators.len(),
|
|
duties.len(),
|
|
"there should be a duty for each validator"
|
|
);
|
|
|
|
let mut state = beacon_chain
|
|
.state_at_slot(
|
|
epoch.start_slot(T::EthSpec::slots_per_epoch()),
|
|
StateSkipConfig::WithStateRoots,
|
|
)
|
|
.expect("should get state at slot");
|
|
|
|
state.build_all_caches(spec).expect("should build caches");
|
|
|
|
validators
|
|
.iter()
|
|
.zip(duties.iter())
|
|
.for_each(|(validator, duty)| {
|
|
assert_eq!(
|
|
*validator,
|
|
(&duty.validator_pubkey)
|
|
.try_into()
|
|
.expect("should be valid pubkey"),
|
|
"pubkey should match"
|
|
);
|
|
|
|
let validator_index = state
|
|
.get_validator_index(&validator.clone().into())
|
|
.expect("should have pubkey cache")
|
|
.expect("pubkey should exist");
|
|
|
|
let attestation_duty = state
|
|
.get_attestation_duties(validator_index, RelativeEpoch::Current)
|
|
.expect("should have attestation duties cache")
|
|
.expect("should have attestation duties");
|
|
|
|
assert_eq!(
|
|
Some(attestation_duty.slot),
|
|
duty.attestation_slot,
|
|
"attestation slot should match"
|
|
);
|
|
|
|
assert_eq!(
|
|
Some(attestation_duty.index),
|
|
duty.attestation_committee_index,
|
|
"attestation index should match"
|
|
);
|
|
|
|
if !duty.block_proposal_slots.is_empty() {
|
|
for slot in &duty.block_proposal_slots {
|
|
let expected_proposer = state
|
|
.get_beacon_proposer_index(*slot, spec)
|
|
.expect("should know proposer");
|
|
assert_eq!(
|
|
expected_proposer, validator_index,
|
|
"should get correct proposal slot"
|
|
);
|
|
}
|
|
} else {
|
|
epoch.slot_iter(E::slots_per_epoch()).for_each(|slot| {
|
|
let slot_proposer = state
|
|
.get_beacon_proposer_index(slot, spec)
|
|
.expect("should know proposer");
|
|
assert!(
|
|
slot_proposer != validator_index,
|
|
"validator should not have proposal slot in this epoch"
|
|
)
|
|
})
|
|
}
|
|
});
|
|
|
|
// Validator duties should include a proposer for every slot of the epoch.
|
|
let mut all_proposer_slots: Vec<Slot> = duties
|
|
.iter()
|
|
.flat_map(|duty| duty.block_proposal_slots.clone())
|
|
.collect();
|
|
all_proposer_slots.sort();
|
|
|
|
let all_slots: Vec<Slot> = epoch.slot_iter(E::slots_per_epoch()).collect();
|
|
assert_eq!(all_proposer_slots, all_slots);
|
|
}
|
|
|
|
#[test]
|
|
fn validator_block_post() {
|
|
let mut env = build_env();
|
|
|
|
let spec = &E::default_spec();
|
|
|
|
let mut config = testing_client_config();
|
|
config.genesis = ClientGenesis::Interop {
|
|
validator_count: 8,
|
|
genesis_time: 13_371_337,
|
|
};
|
|
|
|
let node = build_node(&mut env, config);
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let beacon_chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain");
|
|
|
|
let slot = Slot::new(1);
|
|
let randao_reveal = get_randao_reveal(beacon_chain.clone(), slot, spec);
|
|
|
|
let block = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.validator()
|
|
.produce_block(slot, randao_reveal),
|
|
)
|
|
.expect("should fetch block from http api");
|
|
|
|
// Try publishing the block without a signature, ensure it is flagged as invalid.
|
|
let empty_sig_block = SignedBeaconBlock {
|
|
message: block.clone(),
|
|
signature: Signature::empty_signature(),
|
|
};
|
|
let publish_status = env
|
|
.runtime()
|
|
.block_on(remote_node.http.validator().publish_block(empty_sig_block))
|
|
.expect("should publish block");
|
|
if cfg!(not(feature = "fake_crypto")) {
|
|
assert!(
|
|
!publish_status.is_valid(),
|
|
"the unsigned published block should not be valid"
|
|
);
|
|
}
|
|
|
|
let signed_block = sign_block(beacon_chain.clone(), block, spec);
|
|
let block_root = signed_block.canonical_root();
|
|
|
|
let publish_status = env
|
|
.runtime()
|
|
.block_on(remote_node.http.validator().publish_block(signed_block))
|
|
.expect("should publish block");
|
|
|
|
if cfg!(not(feature = "fake_crypto")) {
|
|
assert_eq!(
|
|
publish_status,
|
|
PublishStatus::Valid,
|
|
"the signed published block should be valid"
|
|
);
|
|
}
|
|
|
|
let head = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_head())
|
|
.expect("should get head");
|
|
|
|
assert_eq!(
|
|
head.block_root, block_root,
|
|
"the published block should become the head block"
|
|
);
|
|
|
|
// Note: this heads check is not super useful for this test, however it is include so it get
|
|
// _some_ testing. If you remove this call, make sure it's tested somewhere else.
|
|
let heads = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_heads())
|
|
.expect("should get heads");
|
|
|
|
assert_eq!(heads.len(), 1, "there should be only one head");
|
|
assert_eq!(
|
|
heads,
|
|
vec![HeadBeaconBlock {
|
|
beacon_block_root: head.block_root,
|
|
beacon_block_slot: head.slot,
|
|
}],
|
|
"there should be only one head"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn validator_block_get() {
|
|
let mut env = build_env();
|
|
|
|
let spec = &E::default_spec();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let beacon_chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain");
|
|
|
|
let slot = Slot::new(1);
|
|
let randao_reveal = get_randao_reveal(beacon_chain, slot, spec);
|
|
|
|
let block = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.validator()
|
|
.produce_block(slot, randao_reveal.clone()),
|
|
)
|
|
.expect("should fetch block from http api");
|
|
|
|
let (expected_block, _state) = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain")
|
|
.produce_block(randao_reveal, slot)
|
|
.expect("should produce block");
|
|
|
|
assert_eq!(
|
|
block, expected_block,
|
|
"the block returned from the API should be as expected"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn beacon_state() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let (state_by_slot, root) = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_state_by_slot(Slot::new(0)))
|
|
.expect("should fetch state from http api");
|
|
|
|
let (state_by_root, root_2) = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_state_by_root(root))
|
|
.expect("should fetch state from http api");
|
|
|
|
let mut db_state = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain")
|
|
.state_at_slot(Slot::new(0), StateSkipConfig::WithStateRoots)
|
|
.expect("should find state");
|
|
db_state.drop_all_caches();
|
|
|
|
assert_eq!(
|
|
root, root_2,
|
|
"the two roots returned from the api should be identical"
|
|
);
|
|
assert_eq!(
|
|
root,
|
|
db_state.canonical_root(),
|
|
"root from database should match that from the API"
|
|
);
|
|
assert_eq!(
|
|
state_by_slot, db_state,
|
|
"genesis state by slot from api should match that from the DB"
|
|
);
|
|
assert_eq!(
|
|
state_by_root, db_state,
|
|
"genesis state by root from api should match that from the DB"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn beacon_block() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let (block_by_slot, root) = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_block_by_slot(Slot::new(0)))
|
|
.expect("should fetch block from http api");
|
|
|
|
let (block_by_root, root_2) = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_block_by_root(root))
|
|
.expect("should fetch block from http api");
|
|
|
|
let db_block = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("client should have beacon chain")
|
|
.block_at_slot(Slot::new(0))
|
|
.expect("should find block")
|
|
.expect("block should not be none");
|
|
|
|
assert_eq!(
|
|
root, root_2,
|
|
"the two roots returned from the api should be identical"
|
|
);
|
|
assert_eq!(
|
|
root,
|
|
db_block.canonical_root(),
|
|
"root from database should match that from the API"
|
|
);
|
|
assert_eq!(
|
|
block_by_slot, db_block,
|
|
"genesis block by slot from api should match that from the DB"
|
|
);
|
|
assert_eq!(
|
|
block_by_root, db_block,
|
|
"genesis block by root from api should match that from the DB"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn genesis_time() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let genesis_time = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_genesis_time())
|
|
.expect("should fetch genesis time from http api");
|
|
|
|
assert_eq!(
|
|
node.client
|
|
.beacon_chain()
|
|
.expect("should have beacon chain")
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.genesis_time,
|
|
genesis_time,
|
|
"should match genesis time from head state"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fork() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let fork = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_fork())
|
|
.expect("should fetch from http api");
|
|
|
|
assert_eq!(
|
|
node.client
|
|
.beacon_chain()
|
|
.expect("should have beacon chain")
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.fork,
|
|
fork,
|
|
"should match head state"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn eth2_config() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let eth2_config = env
|
|
.runtime()
|
|
.block_on(remote_node.http.spec().get_eth2_config())
|
|
.expect("should fetch eth2 config from http api");
|
|
|
|
// TODO: check the entire eth2_config, not just the spec.
|
|
|
|
assert_eq!(
|
|
node.client
|
|
.beacon_chain()
|
|
.expect("should have beacon chain")
|
|
.spec,
|
|
eth2_config.spec,
|
|
"should match genesis time from head state"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn get_version() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let version = env
|
|
.runtime()
|
|
.block_on(remote_node.http.node().get_version())
|
|
.expect("should fetch eth2 config from http api");
|
|
|
|
assert_eq!(version::version(), version, "result should be as expected");
|
|
}
|
|
|
|
#[test]
|
|
fn get_genesis_state_root() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let slot = Slot::new(0);
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_state_root(slot))
|
|
.expect("should fetch from http api");
|
|
|
|
let expected = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("should have beacon chain")
|
|
.rev_iter_state_roots()
|
|
.expect("should get iter")
|
|
.find(|(_cur_root, cur_slot)| slot == *cur_slot)
|
|
.map(|(cur_root, _)| cur_root)
|
|
.expect("chain should have state root at slot");
|
|
|
|
assert_eq!(result, expected, "result should be as expected");
|
|
}
|
|
|
|
#[test]
|
|
fn get_genesis_block_root() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let slot = Slot::new(0);
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_block_root(slot))
|
|
.expect("should fetch from http api");
|
|
|
|
let expected = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("should have beacon chain")
|
|
.rev_iter_block_roots()
|
|
.expect("should get iter")
|
|
.find(|(_cur_root, cur_slot)| slot == *cur_slot)
|
|
.map(|(cur_root, _)| cur_root)
|
|
.expect("chain should have state root at slot");
|
|
|
|
assert_eq!(result, expected, "result should be as expected");
|
|
}
|
|
|
|
#[test]
|
|
fn get_validators() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
let state = &chain.head().expect("should get head").beacon_state;
|
|
|
|
let validators = state.validators.iter().take(2).collect::<Vec<_>>();
|
|
let pubkeys = validators
|
|
.iter()
|
|
.map(|v| (&v.pubkey).try_into().expect("should decode pubkey bytes"))
|
|
.collect();
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_validators(pubkeys, None))
|
|
.expect("should fetch from http api");
|
|
|
|
result
|
|
.iter()
|
|
.zip(validators.iter())
|
|
.for_each(|(response, validator)| compare_validator_response(state, response, validator));
|
|
}
|
|
|
|
#[test]
|
|
fn get_all_validators() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
let state = &chain.head().expect("should get head").beacon_state;
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_all_validators(None))
|
|
.expect("should fetch from http api");
|
|
|
|
result
|
|
.iter()
|
|
.zip(state.validators.iter())
|
|
.for_each(|(response, validator)| compare_validator_response(state, response, validator));
|
|
}
|
|
|
|
#[test]
|
|
fn get_active_validators() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
let state = &chain.head().expect("should get head").beacon_state;
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_active_validators(None))
|
|
.expect("should fetch from http api");
|
|
|
|
/*
|
|
* This test isn't comprehensive because all of the validators in the state are active (i.e.,
|
|
* there is no one to exclude.
|
|
*
|
|
* This should be fixed once we can generate more interesting scenarios with the
|
|
* `NodeTestRig`.
|
|
*/
|
|
|
|
let validators = state
|
|
.validators
|
|
.iter()
|
|
.filter(|validator| validator.is_active_at(state.current_epoch()));
|
|
|
|
result
|
|
.iter()
|
|
.zip(validators)
|
|
.for_each(|(response, validator)| compare_validator_response(state, response, validator));
|
|
}
|
|
|
|
#[test]
|
|
fn get_committees() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
|
|
let epoch = Epoch::new(0);
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.beacon().get_committees(epoch))
|
|
.expect("should fetch from http api");
|
|
|
|
let expected = chain
|
|
.head()
|
|
.expect("should get head")
|
|
.beacon_state
|
|
.get_beacon_committees_at_epoch(RelativeEpoch::Current)
|
|
.expect("should get committees")
|
|
.iter()
|
|
.map(|c| Committee {
|
|
slot: c.slot,
|
|
index: c.index,
|
|
committee: c.committee.to_vec(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
assert_eq!(result, expected, "result should be as expected");
|
|
}
|
|
|
|
#[test]
|
|
fn get_fork_choice() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let fork_choice = env
|
|
.runtime()
|
|
.block_on(remote_node.http.advanced().get_fork_choice())
|
|
.expect("should not error when getting fork choice");
|
|
|
|
assert_eq!(
|
|
fork_choice,
|
|
*node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain")
|
|
.fork_choice
|
|
.core_proto_array(),
|
|
"result should be as expected"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn get_operation_pool() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(remote_node.http.advanced().get_operation_pool())
|
|
.expect("should not error when getting fork choice");
|
|
|
|
let expected = PersistedOperationPool::from_operation_pool(
|
|
&node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have chain")
|
|
.op_pool,
|
|
);
|
|
|
|
assert_eq!(result, expected, "result should be as expected");
|
|
}
|
|
|
|
fn compare_validator_response<T: EthSpec>(
|
|
state: &BeaconState<T>,
|
|
response: &ValidatorResponse,
|
|
validator: &Validator,
|
|
) {
|
|
let response_validator = response.validator.clone().expect("should have validator");
|
|
let i = response
|
|
.validator_index
|
|
.expect("should have validator index");
|
|
let balance = response.balance.expect("should have balance");
|
|
|
|
assert_eq!(response.pubkey, validator.pubkey, "pubkey");
|
|
assert_eq!(response_validator, *validator, "validator");
|
|
assert_eq!(state.balances[i], balance, "balances");
|
|
assert_eq!(state.validators[i], *validator, "validator index");
|
|
}
|
|
|
|
#[test]
|
|
fn proposer_slashing() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
|
|
let state = chain
|
|
.head()
|
|
.expect("should have retrieved state")
|
|
.beacon_state;
|
|
|
|
let spec = &chain.spec;
|
|
|
|
// Check that there are no proposer slashings before insertion
|
|
let (proposer_slashings, _attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(proposer_slashings.len(), 0);
|
|
|
|
let slot = state.slot;
|
|
let proposer_index = chain
|
|
.block_proposer(slot)
|
|
.expect("should get proposer index");
|
|
let keypair = generate_deterministic_keypair(proposer_index);
|
|
let key = &keypair.sk;
|
|
let fork = &state.fork;
|
|
let proposer_slashing = build_proposer_slashing::<E>(
|
|
ProposerSlashingTestTask::Valid,
|
|
proposer_index as u64,
|
|
&key,
|
|
fork,
|
|
spec,
|
|
);
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.beacon()
|
|
.proposer_slashing(proposer_slashing.clone()),
|
|
)
|
|
.expect("should fetch from http api");
|
|
assert!(result, true);
|
|
|
|
// Length should be just one as we've inserted only one proposer slashing
|
|
let (proposer_slashings, _attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(proposer_slashings.len(), 1);
|
|
assert_eq!(proposer_slashing.clone(), proposer_slashings[0]);
|
|
|
|
let mut invalid_proposer_slashing = build_proposer_slashing::<E>(
|
|
ProposerSlashingTestTask::Valid,
|
|
proposer_index as u64,
|
|
&key,
|
|
fork,
|
|
spec,
|
|
);
|
|
invalid_proposer_slashing.signed_header_2 = invalid_proposer_slashing.signed_header_1.clone();
|
|
|
|
let result = env.runtime().block_on(
|
|
remote_node
|
|
.http
|
|
.beacon()
|
|
.proposer_slashing(invalid_proposer_slashing),
|
|
);
|
|
assert!(result.is_err());
|
|
|
|
// Length should still be one as we've inserted nothing since last time.
|
|
let (proposer_slashings, _attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(proposer_slashings.len(), 1);
|
|
assert_eq!(proposer_slashing, proposer_slashings[0]);
|
|
}
|
|
|
|
#[test]
|
|
fn attester_slashing() {
|
|
let mut env = build_env();
|
|
|
|
let node = build_node(&mut env, testing_client_config());
|
|
let remote_node = node.remote_node().expect("should produce remote node");
|
|
let chain = node
|
|
.client
|
|
.beacon_chain()
|
|
.expect("node should have beacon chain");
|
|
|
|
let state = chain
|
|
.head()
|
|
.expect("should have retrieved state")
|
|
.beacon_state;
|
|
let slot = state.slot;
|
|
let spec = &chain.spec;
|
|
|
|
let proposer_index = chain
|
|
.block_proposer(slot)
|
|
.expect("should get proposer index");
|
|
let keypair = generate_deterministic_keypair(proposer_index);
|
|
|
|
let secret_keys = vec![&keypair.sk];
|
|
let validator_indices = vec![proposer_index as u64];
|
|
let fork = &state.fork;
|
|
|
|
// Checking there are no attester slashings before insertion
|
|
let (_proposer_slashings, attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(attester_slashings.len(), 0);
|
|
|
|
let attester_slashing = build_double_vote_attester_slashing(
|
|
AttesterSlashingTestTask::Valid,
|
|
&validator_indices[..],
|
|
&secret_keys[..],
|
|
fork,
|
|
spec,
|
|
);
|
|
|
|
let result = env
|
|
.runtime()
|
|
.block_on(
|
|
remote_node
|
|
.http
|
|
.beacon()
|
|
.attester_slashing(attester_slashing.clone()),
|
|
)
|
|
.expect("should fetch from http api");
|
|
assert!(result, true);
|
|
|
|
// Length should be just one as we've inserted only one attester slashing
|
|
let (_proposer_slashings, attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(attester_slashings.len(), 1);
|
|
assert_eq!(attester_slashing, attester_slashings[0]);
|
|
|
|
// Building an invalid attester slashing
|
|
let mut invalid_attester_slashing = build_double_vote_attester_slashing(
|
|
AttesterSlashingTestTask::Valid,
|
|
&validator_indices[..],
|
|
&secret_keys[..],
|
|
fork,
|
|
spec,
|
|
);
|
|
invalid_attester_slashing.attestation_2 = invalid_attester_slashing.attestation_1.clone();
|
|
|
|
let result = env.runtime().block_on(
|
|
remote_node
|
|
.http
|
|
.beacon()
|
|
.attester_slashing(invalid_attester_slashing),
|
|
);
|
|
assert!(result.is_err());
|
|
|
|
// Length should still be one as we've failed to insert the attester slashing.
|
|
let (_proposer_slashings, attester_slashings) = chain.op_pool.get_slashings(&state, spec);
|
|
assert_eq!(attester_slashings.len(), 1);
|
|
assert_eq!(attester_slashing, attester_slashings[0]);
|
|
}
|