Merge pull request #473 from EspressoSystems/ak/handover-test

Timeboost committee switch-over e2e test

Author: akonring

.config/nextest.toml

@@ -1,2 +1,7 @@
 [profile.default]
 slow-timeout = { period = "60s", terminate-after = 2 }
+
+[[profile.default.overrides]]
+filter = 'test(/^tests::timeboost::timeboost_handover::/)'
+threads-required = 2
+slow-timeout = { period = "300s", terminate-after = 1 }

Cargo.lock

@@ -194,6 +194,13 @@ impl AddressableCommittee {
             .map(|(k, (x, a))| (*k, *x, a.clone()))
     }
 
+    pub fn update_addresses<F>(&mut self, f: F)
+    where
+        F: Fn(&Address) -> Address,
+    {
+        self.addresses.values_mut().for_each(|(_, a)| *a = f(a))
+    }
+
     /// Assert that addresses and committee have the same keys.
     fn assert_shared_domain(&self) {
         for p in self.committee.parties() {

cliquenet/src/addr.rs

@@ -1,23 +1,28 @@
 mod block_order;
 mod handover;
 mod test_timeboost_startup;
+mod timeboost_handover;
 mod transaction_order;
 
+use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use std::num::NonZeroUsize;
+use std::sync::atomic::{AtomicU64, Ordering};
 
-use alloy::eips::BlockNumberOrTag;
+use alloy::eips::{BlockNumberOrTag, Encodable2718};
+use bytes::Bytes;
 use cliquenet::{Address, AddressableCommittee};
+use metrics::NoMetrics;
 use multisig::Keypair;
 use multisig::{Committee, x25519};
-use sailfish_types::UNKNOWN_COMMITTEE_ID;
+use parking_lot::Mutex;
+use sailfish_types::{RoundNumber, UNKNOWN_COMMITTEE_ID};
 use test_utils::ports::alloc_ports;
 use timeboost::builder::CertifierConfig;
 use timeboost::config::{ChainConfig, ParentChain};
 use timeboost::crypto::prelude::DkgDecKey;
-use timeboost::sequencer::SequencerConfig;
-use timeboost::types::BundleVariant;
-use timeboost::types::{DecryptionKeyCell, KeyStore};
+use timeboost::sequencer::{Sequencer, SequencerConfig};
+use timeboost::types::{BlockNumber, BundleVariant, DecryptionKeyCell, KeyStore, Transaction};
 use timeboost_utils::load_generation::make_bundle;
 use tokio::sync::broadcast;
 use tokio::time::{Duration, sleep};
@@ -151,3 +156,38 @@ async fn gen_bundles(enc_key: DecryptionKeyCell, tx: broadcast::Sender<BundleVar
         sleep(Duration::from_millis(10)).await
     }
 }
+
+fn hash(tx: &[Transaction]) -> Bytes {
+    let mut h = blake3::Hasher::new();
+    for t in tx {
+        h.update(&t.encoded_2718());
+    }
+    Bytes::copy_from_slice(h.finalize().as_bytes())
+}
+
+/// Map round numbers to block numbers.
+///
+/// Block numbers need to be consistent, consecutive and strictly monotonic.
+/// The round numbers of our sequencer output may contain gaps. To provide
+/// block numbers with the required properties we have here one monotonic
+/// counter and record which block number is used for a round number.
+/// Subsequent lookups will then get a consistent result.
+struct Round2Block {
+    counter: AtomicU64,
+    block_numbers: Mutex<HashMap<RoundNumber, BlockNumber>>,
+}
+
+impl Round2Block {
+    fn new() -> Self {
+        Self {
+            counter: AtomicU64::new(0),
+            block_numbers: Mutex::new(HashMap::new()),
+        }
+    }
+
+    fn get(&self, r: RoundNumber) -> BlockNumber {
+        let mut map = self.block_numbers.lock();
+        *map.entry(r)
+            .or_insert_with(|| self.counter.fetch_add(1, Ordering::Relaxed).into())
+    }
+}

tests/src/tests/timeboost.rs

@@ -2,18 +2,13 @@ use std::collections::HashMap;
 use std::iter::once;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::Duration;
 
-use alloy::eips::Encodable2718;
-use bytes::Bytes;
 use metrics::NoMetrics;
 use multisig::Certificate;
-use parking_lot::Mutex;
 use timeboost::builder::Certifier;
 use timeboost::sequencer::{Output, Sequencer};
-use timeboost::types::sailfish::RoundNumber;
-use timeboost::types::{Block, BlockInfo, BlockNumber, Transaction};
+use timeboost::types::{Block, BlockInfo};
 use timeboost_utils::types::logging::init_logging;
 use tokio::select;
 use tokio::sync::broadcast::error::RecvError;
@@ -23,6 +18,8 @@ use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 use tracing::{debug, error, info};
 
+use crate::tests::timeboost::{Round2Block, hash};
+
 use super::{gen_bundles, make_configs};
 
 const NUM_OF_BLOCKS: usize = 50;
@@ -56,6 +53,7 @@ async fn block_order() {
             let mut s = Sequencer::new(c, &NoMetrics).await.unwrap();
             let mut p = Certifier::new(b, &NoMetrics).await.unwrap();
             let mut r = None;
+
             let handle = p.handle();
             loop {
                 select! {
@@ -124,38 +122,3 @@ async fn block_order() {
 
     finish.cancel();
 }
-
-fn hash(tx: &[Transaction]) -> Bytes {
-    let mut h = blake3::Hasher::new();
-    for t in tx {
-        h.update(&t.encoded_2718());
-    }
-    Bytes::copy_from_slice(h.finalize().as_bytes())
-}
-
-/// Map round numbers to block numbers.
-///
-/// Block numbers need to be consistent, consecutive and strictly monotonic.
-/// The round numbers of our sequencer output may contain gaps. To provide
-/// block numbers with the required properties we have here one monotonic
-/// counter and record which block number is used for a round number.
-/// Subsequent lookups will then get a consistent result.
-struct Round2Block {
-    counter: AtomicU64,
-    block_numbers: Mutex<HashMap<RoundNumber, BlockNumber>>,
-}
-
-impl Round2Block {
-    fn new() -> Self {
-        Self {
-            counter: AtomicU64::new(0),
-            block_numbers: Mutex::new(HashMap::new()),
-        }
-    }
-
-    fn get(&self, r: RoundNumber) -> BlockNumber {
-        let mut map = self.block_numbers.lock();
-        *map.entry(r)
-            .or_insert_with(|| self.counter.fetch_add(1, Ordering::Relaxed).into())
-    }
-}

tests/src/tests/timeboost/block_order.rs

@@ -183,19 +183,17 @@ where
 ///
 /// NB that the decryption parts of the config are not used yet.
 async fn mk_node(cfg: &SequencerConfig) -> Coordinator<Timestamp, Rbc<Timestamp>> {
-    let met = NetworkMetrics::new(
-        "sailfish",
-        &NoMetrics,
-        cfg.sailfish_committee().parties().copied(),
-    );
-
     let mut net = Network::create(
         "sailfish",
         cfg.sailfish_address().clone(),
         cfg.sign_keypair().public_key(),
         cfg.dh_keypair().clone(),
         cfg.sailfish_committee().entries(),
-        met,
+        NetworkMetrics::new(
+            "sailfish",
+            &NoMetrics,
+            cfg.sailfish_committee().parties().copied(),
+        ),
     )
     .await
     .unwrap();