Merge latest master in v0.2.0

tests/ef_tests/Makefile

@@ -1,5 +1,5 @@
 # Bump the test tag here and in .gitlab-ci.yml and CI will take care of updating the cached tarballs
-TESTS_TAG := v0.10.1
+TESTS_TAG := v0.11.1
 TESTS = general minimal mainnet
 TARBALLS = $(patsubst %,%-$(TESTS_TAG).tar.gz,$(TESTS))
 

tests/ef_tests/src/cases/epoch_processing.rs

@@ -81,7 +81,11 @@ impl<E: EthSpec> EpochTransition<E> for Slashings {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
         let mut validator_statuses = ValidatorStatuses::new(&state, spec)?;
         validator_statuses.process_attestations(&state, spec)?;
-        process_slashings(state, validator_statuses.total_balances.current_epoch, spec)?;
+        process_slashings(
+            state,
+            validator_statuses.total_balances.current_epoch(),
+            spec,
+        )?;
         Ok(())
     }
 }

tests/ef_tests/tests/tests.rs

@@ -176,7 +176,6 @@ mod ssz_static {
     ssz_static_test!(voluntary_exit, VoluntaryExit);
 }
 
-/* NOTE: SSZ generic tests disabled, missing from v0.10.0
 #[test]
 fn ssz_generic() {
     SszGenericHandler::<BasicVector>::run();
@@ -186,7 +185,6 @@ fn ssz_generic() {
     SszGenericHandler::<Uints>::run();
     SszGenericHandler::<Containers>::run();
 }
-*/
 
 #[test]
 fn epoch_processing_justification_and_finalization() {

tests/eth1_test_rig/src/lib.rs

@@ -7,7 +7,9 @@
 //! some initial issues.
 mod ganache;
 
-use deposit_contract::{eth1_tx_data, testnet, ABI, BYTECODE, CONTRACT_DEPLOY_GAS, DEPOSIT_GAS};
+use deposit_contract::{
+    encode_eth1_tx_data, testnet, ABI, BYTECODE, CONTRACT_DEPLOY_GAS, DEPOSIT_GAS,
+};
 use futures::{future, stream, Future, IntoFuture, Stream};
 use ganache::GanacheInstance;
 use std::time::{Duration, Instant};
@@ -201,12 +203,12 @@ impl DepositContract {
                     gas_price: None,
                     value: Some(from_gwei(deposit_data.amount)),
                     // Note: the reason we use this `TransactionRequest` instead of just using the
-                    // function in `self.contract` is so that the `eth1_tx_data` function gets used
+                    // function in `self.contract` is so that the `encode_eth1_tx_data` function gets used
                     // during testing.
                     //
-                    // It's important that `eth1_tx_data` stays correct and does not suffer from
+                    // It's important that `encode_eth1_tx_data` stays correct and does not suffer from
                     // code-rot.
-                    data: eth1_tx_data(&deposit_data).map(Into::into).ok(),
+                    data: encode_eth1_tx_data(&deposit_data).map(Into::into).ok(),
                     nonce: None,
                     condition: None,
                 };

tests/simulator/src/cli.rs

@@ -88,17 +88,17 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                         .help("Epoch delay for new beacon node to start syncing (default 50)"),
                 )
                 .arg(
-                    Arg::with_name("sync_delay")
-                        .long("sync_delay")
+                    Arg::with_name("sync_timeout")
+                        .long("sync_timeout")
                         .takes_value(true)
-                        .help("Epoch delay for newly added beacon nodes get synced (default 10)"),
+                        .help("Number of epochs after which newly added beacon nodes must be synced (default 10)"),
                 )
                 .arg(
                     Arg::with_name("strategy")
                         .long("strategy")
                         .takes_value(true)
                         .possible_values(&["one-node", "two-nodes", "mixed", "all"])
-                        .help("Sync strategy to run. (default all)"),
+                        .help("Sync verification strategy to run. (default all)"),
                 ),
         )
 }

tests/simulator/src/local_network.rs

@@ -94,7 +94,7 @@ impl<E: EthSpec> LocalNetwork<E> {
                         .expect("bootnode must have a network"),
                 );
             })
-            .expect("should have atleast one node");
+            .expect("should have at least one node");
 
         let index = self.beacon_nodes.read().len();
 

tests/simulator/src/sync_sim.rs

@@ -1,10 +1,11 @@
 use crate::checks::{epoch_delay, verify_all_finalized_at};
 use crate::local_network::LocalNetwork;
 use clap::ArgMatches;
-use futures::{future, Future, IntoFuture};
+use futures::{future, stream, Future, IntoFuture, Stream};
 use node_test_rig::ClientConfig;
 use node_test_rig::{environment::EnvironmentBuilder, testing_client_config, ValidatorConfig};
 use std::time::Duration;
+use tokio::timer::Interval;
 use types::{Epoch, EthSpec};
 
 pub fn run_syncing_sim(matches: &ArgMatches) -> Result<(), String> {
@@ -117,7 +118,7 @@ pub fn pick_strategy<E: EthSpec>(
     beacon_config: ClientConfig,
     slot_duration: Duration,
     initial_delay: u64,
-    sync_delay: u64,
+    sync_timeout: u64,
 ) -> Box<dyn Future<Item = (), Error = String> + Send + 'static> {
     match strategy {
         "one-node" => Box::new(verify_one_node_sync(
@@ -125,42 +126,44 @@ pub fn pick_strategy<E: EthSpec>(
             beacon_config,
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )),
         "two-nodes" => Box::new(verify_two_nodes_sync(
             network,
             beacon_config,
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )),
         "mixed" => Box::new(verify_in_between_sync(
             network,
             beacon_config,
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )),
         "all" => Box::new(verify_syncing(
             network,
             beacon_config,
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )),
         _ => Box::new(Err("Invalid strategy".into()).into_future()),
     }
 }
 
 /// Verify one node added after `initial_delay` epochs is in sync
-/// after `sync_delay` epochs.
+/// after `sync_timeout` epochs.
 pub fn verify_one_node_sync<E: EthSpec>(
     network: LocalNetwork<E>,
     beacon_config: ClientConfig,
     slot_duration: Duration,
     initial_delay: u64,
-    sync_delay: u64,
+    sync_timeout: u64,
 ) -> impl Future<Item = (), Error = String> {
+    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
+    let network_c = network.clone();
     // Delay for `initial_delay` epochs before adding another node to start syncing
     epoch_delay(
         Epoch::new(initial_delay),
@@ -172,8 +175,14 @@ pub fn verify_one_node_sync<E: EthSpec>(
         network.add_beacon_node(beacon_config).map(|_| network)
     })
     .and_then(move |network| {
-        // Delay for `sync_delay` epochs before verifying synced state.
-        epoch_delay(Epoch::new(sync_delay), slot_duration, E::slots_per_epoch()).map(|_| network)
+        // Check every `epoch_duration` if nodes are synced
+        // limited to at most `sync_timeout` epochs
+        Interval::new_interval(epoch_duration)
+            .take(sync_timeout)
+            .map_err(|_| "Failed to create interval".to_string())
+            .take_while(move |_| check_still_syncing(&network_c))
+            .for_each(|_| Ok(())) // consume the stream
+            .map(|_| network)
     })
     .and_then(move |network| network.bootnode_epoch().map(|e| (e, network)))
     .and_then(move |(epoch, network)| {
@@ -182,14 +191,16 @@ pub fn verify_one_node_sync<E: EthSpec>(
 }
 
 /// Verify two nodes added after `initial_delay` epochs are in sync
-/// after `sync_delay` epochs.
+/// after `sync_timeout` epochs.
 pub fn verify_two_nodes_sync<E: EthSpec>(
     network: LocalNetwork<E>,
     beacon_config: ClientConfig,
     slot_duration: Duration,
     initial_delay: u64,
-    sync_delay: u64,
+    sync_timeout: u64,
 ) -> impl Future<Item = (), Error = String> {
+    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
+    let network_c = network.clone();
     // Delay for `initial_delay` epochs before adding another node to start syncing
     epoch_delay(
         Epoch::new(initial_delay),
@@ -200,12 +211,20 @@ pub fn verify_two_nodes_sync<E: EthSpec>(
         // Add beacon nodes
         network
             .add_beacon_node(beacon_config.clone())
-            .join(network.add_beacon_node(beacon_config.clone()))
-            .map(|_| network)
+            .map(|_| (network, beacon_config))
+            .and_then(|(network, beacon_config)| {
+                network.add_beacon_node(beacon_config).map(|_| network)
+            })
     })
     .and_then(move |network| {
-        // Delay for `sync_delay` epochs before verifying synced state.
-        epoch_delay(Epoch::new(sync_delay), slot_duration, E::slots_per_epoch()).map(|_| network)
+        // Check every `epoch_duration` if nodes are synced
+        // limited to at most `sync_timeout` epochs
+        Interval::new_interval(epoch_duration)
+            .take(sync_timeout)
+            .map_err(|_| "Failed to create interval".to_string())
+            .take_while(move |_| check_still_syncing(&network_c))
+            .for_each(|_| Ok(())) // consume the stream
+            .map(|_| network)
     })
     .and_then(move |network| network.bootnode_epoch().map(|e| (e, network)))
     .and_then(move |(epoch, network)| {
@@ -214,15 +233,17 @@ pub fn verify_two_nodes_sync<E: EthSpec>(
 }
 
 /// Add 2 syncing nodes after `initial_delay` epochs,
-/// Add another node after `sync_delay - 5` epochs and verify all are
-/// in sync after `sync_delay + 5` epochs.
+/// Add another node after `sync_timeout - 5` epochs and verify all are
+/// in sync after `sync_timeout + 5` epochs.
 pub fn verify_in_between_sync<E: EthSpec>(
     network: LocalNetwork<E>,
     beacon_config: ClientConfig,
     slot_duration: Duration,
     initial_delay: u64,
-    sync_delay: u64,
+    sync_timeout: u64,
 ) -> impl Future<Item = (), Error = String> {
+    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
+    let network_c = network.clone();
     // Delay for `initial_delay` epochs before adding another node to start syncing
     let config1 = beacon_config.clone();
     epoch_delay(
@@ -234,13 +255,15 @@ pub fn verify_in_between_sync<E: EthSpec>(
         // Add a beacon node
         network
             .add_beacon_node(beacon_config.clone())
-            .join(network.add_beacon_node(beacon_config.clone()))
-            .map(|_| network)
+            .map(|_| (network, beacon_config))
+            .and_then(|(network, beacon_config)| {
+                network.add_beacon_node(beacon_config).map(|_| network)
+            })
     })
     .and_then(move |network| {
         // Delay before adding additional syncing nodes.
         epoch_delay(
-            Epoch::new(sync_delay - 5),
+            Epoch::new(sync_timeout - 5),
             slot_duration,
             E::slots_per_epoch(),
         )
@@ -251,13 +274,14 @@ pub fn verify_in_between_sync<E: EthSpec>(
         network.add_beacon_node(config1.clone()).map(|_| network)
     })
     .and_then(move |network| {
-        // Delay for `sync_delay` epochs before verifying synced state.
-        epoch_delay(
-            Epoch::new(sync_delay + 5),
-            slot_duration,
-            E::slots_per_epoch(),
-        )
-        .map(|_| network)
+        // Check every `epoch_duration` if nodes are synced
+        // limited to at most `sync_timeout` epochs
+        Interval::new_interval(epoch_duration)
+            .take(sync_timeout + 5)
+            .map_err(|_| "Failed to create interval".to_string())
+            .take_while(move |_| check_still_syncing(&network_c))
+            .for_each(|_| Ok(())) // consume the stream
+            .map(|_| network)
     })
     .and_then(move |network| network.bootnode_epoch().map(|e| (e, network)))
     .and_then(move |(epoch, network)| {
@@ -271,14 +295,14 @@ pub fn verify_syncing<E: EthSpec>(
     beacon_config: ClientConfig,
     slot_duration: Duration,
     initial_delay: u64,
-    sync_delay: u64,
+    sync_timeout: u64,
 ) -> impl Future<Item = (), Error = String> {
     verify_one_node_sync(
         network.clone(),
         beacon_config.clone(),
         slot_duration,
         initial_delay,
-        sync_delay,
+        sync_timeout,
     )
     .map(|_| println!("Completed one node sync"))
     .and_then(move |_| {
@@ -287,7 +311,7 @@ pub fn verify_syncing<E: EthSpec>(
             beacon_config.clone(),
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )
         .map(|_| {
             println!("Completed two node sync");
@@ -300,8 +324,36 @@ pub fn verify_syncing<E: EthSpec>(
             beacon_config,
             slot_duration,
             initial_delay,
-            sync_delay,
+            sync_timeout,
         )
         .map(|_| println!("Completed in between sync"))
     })
 }
+
+pub fn check_still_syncing<E: EthSpec>(
+    network: &LocalNetwork<E>,
+) -> impl Future<Item = bool, Error = String> {
+    let net = network.clone();
+    network
+        .remote_nodes()
+        .into_future()
+        // get all head epochs
+        .and_then(|remote_nodes| {
+            stream::unfold(remote_nodes.into_iter(), |mut iter| {
+                iter.next().map(|remote_node| {
+                    remote_node
+                        .http
+                        .beacon()
+                        .get_head()
+                        .map(|head| head.finalized_slot.epoch(E::slots_per_epoch()))
+                        .map(|epoch| (epoch, iter))
+                        .map_err(|e| format!("Get head via http failed: {:?}", e))
+                })
+            })
+            .collect()
+        })
+        // find current epoch
+        .and_then(move |epochs| net.bootnode_epoch().map(|epoch| (epochs, epoch)))
+        .and_then(move |(epochs, epoch)| Ok(epochs.iter().any(|head_epoch| *head_epoch != epoch)))
+        .map_err(|e| format!("Failed syncing check: {:?}", e))
+}