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>
148 lines
6.1 KiB
Rust
148 lines
6.1 KiB
Rust
#![cfg(test)]
|
|
use crate::types::GossipEncoding;
|
|
use ::types::{BeaconBlock, EthSpec, MinimalEthSpec, Signature, SignedBeaconBlock};
|
|
use eth2_libp2p::*;
|
|
use futures::prelude::*;
|
|
use slog::{debug, Level};
|
|
|
|
type E = MinimalEthSpec;
|
|
|
|
mod common;
|
|
|
|
/* Gossipsub tests */
|
|
// Note: The aim of these tests is not to test the robustness of the gossip network
|
|
// but to check if the gossipsub implementation is behaving according to the specifications.
|
|
|
|
// Test if gossipsub message are forwarded by nodes with a simple linear topology.
|
|
//
|
|
// Topology used in test
|
|
//
|
|
// node1 <-> node2 <-> node3 ..... <-> node(n-1) <-> node(n)
|
|
|
|
#[test]
|
|
fn test_gossipsub_forward() {
|
|
// set up the logging. The level and enabled or not
|
|
let log = common::build_log(Level::Info, false);
|
|
|
|
let num_nodes = 20;
|
|
let mut nodes = common::build_linear(log.clone(), num_nodes, Some(19000));
|
|
let mut received_count = 0;
|
|
let spec = E::default_spec();
|
|
let empty_block = BeaconBlock::empty(&spec);
|
|
let signed_block = SignedBeaconBlock {
|
|
message: empty_block,
|
|
signature: Signature::empty_signature(),
|
|
};
|
|
let data = PubsubData::BeaconBlock(Box::new(signed_block));
|
|
let pubsub_message = PubsubMessage::new(GossipEncoding::SSZ, data);
|
|
let publishing_topic: String = "/eth2/beacon_block/ssz".into();
|
|
let mut subscribed_count = 0;
|
|
tokio::run(futures::future::poll_fn(move || -> Result<_, ()> {
|
|
for node in nodes.iter_mut() {
|
|
loop {
|
|
match node.poll().unwrap() {
|
|
Async::Ready(Some(Libp2pEvent::PubsubMessage {
|
|
topics,
|
|
message,
|
|
source,
|
|
id,
|
|
})) => {
|
|
assert_eq!(topics.len(), 1);
|
|
// Assert topic is the published topic
|
|
assert_eq!(
|
|
topics.first().unwrap(),
|
|
&TopicHash::from_raw(publishing_topic.clone())
|
|
);
|
|
// Assert message received is the correct one
|
|
assert_eq!(message, pubsub_message.clone());
|
|
received_count += 1;
|
|
// Since `propagate_message` is false, need to propagate manually
|
|
node.swarm.propagate_message(&source, id);
|
|
// Test should succeed if all nodes except the publisher receive the message
|
|
if received_count == num_nodes - 1 {
|
|
debug!(log.clone(), "Received message at {} nodes", num_nodes - 1);
|
|
return Ok(Async::Ready(()));
|
|
}
|
|
}
|
|
Async::Ready(Some(Libp2pEvent::PeerSubscribed(_, topic))) => {
|
|
// Received topics is one of subscribed eth2 topics
|
|
assert!(topic.clone().into_string().starts_with("/eth2/"));
|
|
// Publish on beacon block topic
|
|
if topic == TopicHash::from_raw("/eth2/beacon_block/ssz") {
|
|
subscribed_count += 1;
|
|
// Every node except the corner nodes are connected to 2 nodes.
|
|
if subscribed_count == (num_nodes * 2) - 2 {
|
|
node.swarm.publish(vec![pubsub_message.clone()]);
|
|
}
|
|
}
|
|
}
|
|
_ => break,
|
|
}
|
|
}
|
|
}
|
|
Ok(Async::NotReady)
|
|
}))
|
|
}
|
|
|
|
// Test publishing of a message with a full mesh for the topic
|
|
// Not very useful but this is the bare minimum functionality.
|
|
#[test]
|
|
fn test_gossipsub_full_mesh_publish() {
|
|
// set up the logging. The level and enabled or not
|
|
let log = common::build_log(Level::Info, false);
|
|
|
|
// Note: This test does not propagate gossipsub messages.
|
|
// Having `num_nodes` > `mesh_n_high` may give inconsistent results
|
|
// as nodes may get pruned out of the mesh before the gossipsub message
|
|
// is published to them.
|
|
let num_nodes = 12;
|
|
let mut nodes = common::build_full_mesh(log, num_nodes, Some(11320));
|
|
let mut publishing_node = nodes.pop().unwrap();
|
|
let spec = E::default_spec();
|
|
let empty_block = BeaconBlock::empty(&spec);
|
|
let signed_block = SignedBeaconBlock {
|
|
message: empty_block,
|
|
signature: Signature::empty_signature(),
|
|
};
|
|
let data = PubsubData::BeaconBlock(Box::new(signed_block));
|
|
let pubsub_message = PubsubMessage::new(GossipEncoding::SSZ, data);
|
|
let publishing_topic: String = "/eth2/beacon_block/ssz".into();
|
|
let mut subscribed_count = 0;
|
|
let mut received_count = 0;
|
|
tokio::run(futures::future::poll_fn(move || -> Result<_, ()> {
|
|
for node in nodes.iter_mut() {
|
|
while let Async::Ready(Some(Libp2pEvent::PubsubMessage {
|
|
topics, message, ..
|
|
})) = node.poll().unwrap()
|
|
{
|
|
assert_eq!(topics.len(), 1);
|
|
// Assert topic is the published topic
|
|
assert_eq!(
|
|
topics.first().unwrap(),
|
|
&TopicHash::from_raw(publishing_topic.clone())
|
|
);
|
|
// Assert message received is the correct one
|
|
assert_eq!(message, pubsub_message.clone());
|
|
received_count += 1;
|
|
if received_count == num_nodes - 1 {
|
|
return Ok(Async::Ready(()));
|
|
}
|
|
}
|
|
}
|
|
while let Async::Ready(Some(Libp2pEvent::PeerSubscribed(_, topic))) =
|
|
publishing_node.poll().unwrap()
|
|
{
|
|
// Received topics is one of subscribed eth2 topics
|
|
assert!(topic.clone().into_string().starts_with("/eth2/"));
|
|
// Publish on beacon block topic
|
|
if topic == TopicHash::from_raw("/eth2/beacon_block/ssz") {
|
|
subscribed_count += 1;
|
|
if subscribed_count == num_nodes - 1 {
|
|
publishing_node.swarm.publish(vec![pubsub_message.clone()]);
|
|
}
|
|
}
|
|
}
|
|
Ok(Async::NotReady)
|
|
}))
|
|
}
|