Adjustments after review comments.

Author: akonring

cliquenet/src/addr.rs

@@ -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() {

tests/src/tests/timeboost/block_order.rs

@@ -50,12 +50,8 @@ async fn block_order() {
                 // delay start of a recovering node:
                 sleep(Duration::from_secs(5)).await
             }
-            let mut s = Sequencer::new(c.clone(), &NoMetrics)
-                .await
-                .unwrap_or_else(|e| panic!("failed to create sequencer: {e}"));
-            let mut p = Certifier::new(b.clone(), &NoMetrics)
-                .await
-                .unwrap_or_else(|e| panic!("failed to create certifer: {e}"));
+            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();

tests/src/tests/timeboost/timeboost_handover.rs

@@ -62,17 +62,17 @@ async fn run_handover(
 
     // run committee 1 (current):
     for (_, seq_conf, cert_conf) in &curr {
-        let seq_conf = seq_conf.clone();
-        let cert_conf = cert_conf.clone();
+        let sc = seq_conf.clone();
+        let cc = cert_conf.clone();
         let (tx, rx) = mpsc::unbounded_channel();
         let finish = finish.clone();
         let mut cmd = bcast.subscribe();
-        let label = seq_conf.sign_keypair().public_key();
+        let label = sc.sign_keypair().public_key();
         let r2b = round2block.clone();
 
         tasks.spawn(async move {
-            let mut s = Sequencer::new(seq_conf.clone(), &NoMetrics).await.unwrap();
-            let mut c = Certifier::new(cert_conf.clone(), &NoMetrics).await.unwrap();
+            let mut s = Sequencer::new(sc, &NoMetrics).await.unwrap();
+            let mut c = Certifier::new(cc, &NoMetrics).await.unwrap();
             let mut r: Option<RoundNumber> = None;
             let c_handle = c.handle();
 
@@ -181,10 +181,10 @@ async fn run_handover(
         tasks.spawn(async move {
           let mut s = Sequencer::new(seq_conf, &NoMetrics)
                 .await
-                .unwrap_or_else(|e| panic!("failed to create sequencer: {e}"));
+                .unwrap();
             let mut c = Certifier::new(cert_conf, &NoMetrics)
                 .await
-                .unwrap_or_else(|e| panic!("failed to create certifer: {e}"));
+                .unwrap();
             let mut r: Option<sailfish_types::RoundNumber> = None;
             let c_handle = c.handle();
 

tests/src/tests/timeboost/transaction_order.rs

@@ -52,9 +52,7 @@ async fn transaction_order() {
                 // delay start of a recovering node:
                 sleep(Duration::from_secs(5)).await
             }
-            let mut s = Sequencer::new(c.clone(), &NoMetrics)
-                .await
-                .unwrap_or_else(|e| panic!("failed to create sequencer: {e}"));
+            let mut s = Sequencer::new(c.clone(), &NoMetrics).await.unwrap();
             loop {
                 select! {
                     trx = brx.recv() => match trx {

timeboost-builder/src/certifier.rs

@@ -143,11 +143,10 @@ impl Certifier {
     /// Prepare for the next committee.
     pub async fn set_next_committee(
         &mut self,
-        c: AddressableCommittee,
+        mut c: AddressableCommittee,
     ) -> StdResult<(), CertifierDown> {
         debug!(node = %self.label, committee = %c.committee().id(), "next committee");
-        // map to Certifier network
-        let c = translate_addr(c);
+        c.update_addresses(|a| a.to_owned().with_offset(CERTIFIER_PORT_OFFSET));
         self.worker_tx
             .send(Command::NextCommittee(c))
             .await
@@ -166,19 +165,6 @@ impl Certifier {
     }
 }
 
-fn translate_addr(c: AddressableCommittee) -> AddressableCommittee {
-    let committee = c.committee().clone();
-    let shifted_entries = c
-        .entries()
-        .map(|(pk, dh, addr)| {
-            let cert_port = addr.port().saturating_add(CERTIFIER_PORT_OFFSET);
-            let new_addr = addr.with_port(cert_port);
-            (pk, dh, new_addr)
-        })
-        .collect::<Vec<_>>();
-    AddressableCommittee::new(committee, shifted_entries)
-}
-
 impl Drop for Certifier {
     fn drop(&mut self) {
         self.worker.abort()

timeboost-sequencer/src/decrypt.rs

@@ -348,14 +348,13 @@ impl Decrypter {
     /// Prepare for the next committee.
     pub async fn next_committee(
         &mut self,
-        c: AddressableCommittee,
+        mut c: AddressableCommittee,
         k: KeyStore,
     ) -> StdResult<(), DecrypterDown> {
         debug!(node = %self.label, committee = %c.committee().id(), "next committee");
-        // map to Decrypter network
-        let d = translate_addr(c);
+        c.update_addresses(|a| a.to_owned().with_offset(DECRYPTER_PORT_OFFSET));
         self.worker_tx
-            .send(Command::NextCommittee(d, k))
+            .send(Command::NextCommittee(c, k))
             .await
             .map_err(|_| DecrypterDown(()))?;
         Ok(())
@@ -372,19 +371,6 @@ impl Decrypter {
     }
 }
 
-fn translate_addr(c: AddressableCommittee) -> AddressableCommittee {
-    let committee = c.committee().clone();
-    let shifted_entries = c
-        .entries()
-        .map(|(pk, dh, addr)| {
-            let dec_port = addr.port().saturating_add(DECRYPTER_PORT_OFFSET);
-            let new_addr = addr.with_port(dec_port);
-            (pk, dh, new_addr)
-        })
-        .collect::<Vec<_>>();
-    AddressableCommittee::new(committee, shifted_entries)
-}
-
 impl Drop for Decrypter {
     fn drop(&mut self) {
         self.worker.abort()
@@ -2450,7 +2436,7 @@ mod tests {
                 Arc::new(SequencerMetrics::default()),
             )
             .await
-            .unwrap_or_else(|e| panic!("failed to create decrypter: {e}"));
+            .unwrap();
             decrypters.push(decrypter);
             encryption_key_cells.push(encryption_key_cell);
         }

timeboost-types/src/decryption.rs

@@ -410,48 +410,46 @@ impl DkgAccumulator {
     }
 
     /// Try to add a bundle to the accumulator.
-    pub async fn try_add(&mut self, bundle: DkgBundle) -> Result<(), VessError> {
+    pub async fn try_add(&mut self, bundle: DkgBundle) -> anyhow::Result<()> {
         // caller should ensure that no bundles are added after finalization
         if self.bundles().contains(&bundle) || self.complete {
             return Ok(());
         }
 
         let aad: &[u8; 3] = b"dkg";
-        let committee = self.store.committee().clone();
-        let sorted_keys: Vec<DkgEncKey> = self.store.sorted_keys().cloned().collect();
+        let vess = Vess::new_fast();
+        let store = self.store.clone();
         let mode = self.mode.clone();
 
-        spawn_blocking({
-            let bundle = bundle.clone();
-            move || {
-                let vess = Vess::new_fast();
-                match mode {
-                    AccumulatorMode::Dkg => vess.verify_shares(
-                        &committee,
-                        sorted_keys.iter(),
+        let bundle = spawn_blocking(move || {
+            // verify the bundle based on the mode
+            match mode {
+                AccumulatorMode::Dkg => {
+                    vess.verify_shares(
+                        store.committee(),
+                        store.sorted_keys(),
                         bundle.vess_ct(),
                         bundle.comm(),
                         aad,
-                    ),
-                    AccumulatorMode::Resharing(combkey) => {
-                        let Some(pub_share) = combkey.get_pub_share(bundle.origin().0.into())
-                        else {
-                            return Err(VessError::FailedVerification);
-                        };
-                        vess.verify_reshares(
-                            &committee,
-                            sorted_keys.iter(),
-                            bundle.vess_ct(),
-                            bundle.comm(),
-                            aad,
-                            *pub_share,
-                        )
-                    }
+                    )?;
+                }
+                AccumulatorMode::Resharing(combkey) => {
+                    let Some(pub_share) = combkey.get_pub_share(bundle.origin().0.into()) else {
+                        return Err(VessError::FailedVerification);
+                    };
+                    vess.verify_reshares(
+                        store.committee(),
+                        store.sorted_keys(),
+                        bundle.vess_ct(),
+                        bundle.comm(),
+                        aad,
+                        *pub_share,
+                    )?;
                 }
             }
+            Ok(bundle)
         })
-        .await
-        .map_err(|_| VessError::FailedVerification)??;
+        .await??;
 
         self.bundles.push(bundle);
         // only store the necessary amount of bundles in the accumulator

timeboost/src/lib.rs

@@ -1,11 +1,12 @@
 mod conf;
 
+use std::iter::once;
+use std::sync::Arc;
+
 use ::metrics::prometheus::PrometheusMetrics;
 use anyhow::Result;
 use metrics::TimeboostMetrics;
 use multisig::PublicKey;
-use std::iter::once;
-use std::sync::Arc;
 use timeboost_builder::{Certifier, CertifierDown, Submitter};
 use timeboost_sequencer::{Output, Sequencer};
 use timeboost_types::BundleVariant;