Offload verification work to dedicated pool.

Author: akonring

timeboost-sequencer/src/decrypt.rs

@@ -777,12 +777,8 @@ impl Worker {
             return Ok(());
         }
 
-        let key_store = {
-            let guard = self.key_stores.read();
-            guard
-                .get(*committee_id)
-                .ok_or(DecrypterError::NoCommittee(*committee_id))?
-                .clone()
+        let Some(key_store) = self.key_stores.read().get(*committee_id).cloned() else {
+            return Err(DecrypterError::NoCommittee(*committee_id));
         };
 
         let acc = if is_resharing {
@@ -797,6 +793,7 @@ impl Worker {
         };
 
         acc.try_add(bundle)
+            .await
             .map_err(|e| DecrypterError::Dkg(format!("failed to add bundle: {e}")))?;
 
         // for initial DKG, try to finalize if we have enough bundles
@@ -982,7 +979,7 @@ impl Worker {
         Ok(Some(self.finalize_hatch(round, incl).await?))
     }
 
-    /// Get the current decryption key
+    /// Get the current decryption key.
     fn decryption_key(&self) -> Result<DecryptionKey> {
         match &self.state {
             WorkerState::Running => self.dec_key.get().ok_or_else(|| {
@@ -994,7 +991,7 @@ impl Worker {
         }
     }
 
-    /// Get the current key store for the committee.
+    /// Get the key store for the current committee.
     fn current_store(&self) -> Result<KeyStore> {
         let guard = self.key_stores.read();
         guard

timeboost-types/src/decryption.rs

@@ -23,6 +23,7 @@ use timeboost_crypto::{
     vess::VessError,
 };
 use tokio::sync::Notify;
+use tokio::task::spawn_blocking;
 
 use crate::DkgBundle;
 
@@ -409,41 +410,48 @@ impl DkgAccumulator {
     }
 
     /// Try to add a bundle to the accumulator.
-    pub fn try_add(&mut self, bundle: DkgBundle) -> Result<(), VessError> {
+    pub async fn try_add(&mut self, bundle: DkgBundle) -> Result<(), VessError> {
         // 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();
-        let vess = Vess::new_fast();
-
-        // verify the bundle based on the mode
-        match &self.mode {
-            AccumulatorMode::Dkg => {
-                vess.verify_shares(
-                    committee,
-                    self.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,
-                    self.store.sorted_keys(),
-                    bundle.vess_ct(),
-                    bundle.comm(),
-                    aad,
-                    *pub_share,
-                )?;
+        let committee = self.store.committee().clone();
+        let sorted_keys: Vec<DkgEncKey> = self.store.sorted_keys().cloned().collect();
+        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(),
+                        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,
+                        )
+                    }
+                }
             }
-        }
+        })
+        .await
+        .map_err(|_| VessError::FailedVerification)??;
 
         self.bundles.push(bundle);
         // only store the necessary amount of bundles in the accumulator