Check slashability of attestations in batches to avoid sequential bottleneck

common/task_executor/src/rayon_pool_provider.rs

@@ -15,7 +15,7 @@ pub struct RayonPoolProvider {
     /// By default ~25% of CPUs or a minimum of 1 thread.
     low_priority_thread_pool: Arc<ThreadPool>,
     /// Larger rayon thread pool for high-priority, compute-intensive tasks.
-    /// By default ~80% of CPUs or a minimum of 1 thread. Citical/highest
+    /// By default ~80% of CPUs or a minimum of 1 thread. Critical/highest
     /// priority tasks should use the global pool instead.
     high_priority_thread_pool: Arc<ThreadPool>,
 }

testing/web3signer_tests/src/lib.rs

@@ -539,6 +539,56 @@ mod tests {
             }
             self
         }
+
+        /// Assert that a slashable attestation fails to be signed locally (empty result) and is
+        /// either signed or not by the web3signer rig depending on the value of
+        /// `web3signer_should_sign`.
+        ///
+        /// The batch attestation signing API returns an empty result instead of an error for
+        /// slashable attestations.
+        pub async fn assert_slashable_attestation_should_sign<F, R>(
+            self,
+            case_name: &str,
+            generate_sig: F,
+            web3signer_should_sign: bool,
+        ) -> Self
+        where
+            F: Fn(PublicKeyBytes, Arc<LighthouseValidatorStore<TestingSlotClock, E>>) -> R,
+            R: Future<Output = Result<Vec<Attestation<E>>, lighthouse_validator_store::Error>>,
+        {
+            for validator_rig in &self.validator_rigs {
+                let result =
+                    generate_sig(self.validator_pubkey, validator_rig.validator_store.clone())
+                        .await;
+
+                if !validator_rig.using_web3signer || !web3signer_should_sign {
+                    // For local validators, slashable attestations should return an empty result
+                    // or an error.
+                    match result {
+                        Ok(attestations) => {
+                            assert!(
+                                attestations.is_empty(),
+                                "should not sign slashable {case_name}: expected empty result"
+                            );
+                        }
+                        Err(ValidatorStoreError::Slashable(_)) => {
+                            // Also acceptable - error indicates slashable
+                        }
+                        Err(e) => {
+                            panic!("unexpected error for slashable {case_name}: {e:?}");
+                        }
+                    }
+                } else {
+                    // Web3signer should sign (has its own slashing protection)
+                    let attestations = result.expect("should sign slashable {case_name}");
+                    assert!(
+                        !attestations.is_empty(),
+                        "web3signer should sign slashable {case_name}"
+                    );
+                }
+            }
+            self
+        }
     }
 
     /// Get a generic, arbitrary attestation for signing.
@@ -605,12 +655,13 @@ mod tests {
         })
         .await
         .assert_signatures_match("attestation", |pubkey, validator_store| async move {
-            let mut attestation = get_attestation();
+            let attestation = get_attestation();
             validator_store
-                .sign_attestation(pubkey, 0, &mut attestation, Epoch::new(0))
+                .sign_attestations(vec![(pubkey, 0, attestation)])
                 .await
-                .unwrap();
-            attestation
+                .unwrap()
+                .pop()
+                .unwrap()
         })
         .await
         .assert_signatures_match("signed_aggregate", |pubkey, validator_store| async move {
@@ -820,8 +871,6 @@ mod tests {
             block
         };
 
-        let current_epoch = Epoch::new(5);
-
         TestingRig::new(
             network,
             slashing_protection_config,
@@ -830,42 +879,43 @@ mod tests {
         )
         .await
         .assert_signatures_match("first_attestation", |pubkey, validator_store| async move {
-            let mut attestation = first_attestation();
+            let attestation = first_attestation();
             validator_store
-                .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
+                .sign_attestations(vec![(pubkey, 0, attestation)])
                 .await
-                .unwrap();
-            attestation
+                .unwrap()
+                .pop()
+                .unwrap()
         })
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "double_vote_attestation",
             move |pubkey, validator_store| async move {
-                let mut attestation = double_vote_attestation();
+                let attestation = double_vote_attestation();
                 validator_store
-                    .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
+                    .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
             },
             slashable_message_should_sign,
         )
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "surrounding_attestation",
             move |pubkey, validator_store| async move {
-                let mut attestation = surrounding_attestation();
+                let attestation = surrounding_attestation();
                 validator_store
-                    .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
+                    .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
             },
             slashable_message_should_sign,
         )
         .await
-        .assert_slashable_message_should_sign(
+        .assert_slashable_attestation_should_sign(
             "surrounded_attestation",
             move |pubkey, validator_store| async move {
-                let mut attestation = surrounded_attestation();
+                let attestation = surrounded_attestation();
                 validator_store
-                    .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
+                    .sign_attestations(vec![(pubkey, 0, attestation)])
                     .await
             },
             slashable_message_should_sign,

validator_client/http_api/src/tests/keystores.rs

@@ -1099,14 +1099,18 @@ async fn generic_migration_test(
         check_keystore_import_response(&import_res, all_imported(keystores.len()));
 
         // Sign attestations on VC1.
-        for (validator_index, mut attestation) in first_vc_attestations {
+        for (validator_index, attestation) in first_vc_attestations {
             let public_key = keystore_pubkey(&keystores[validator_index]);
-            let current_epoch = attestation.data().target.epoch;
-            tester1
+            let safe_attestations = tester1
                 .validator_store
-                .sign_attestation(public_key, 0, &mut attestation, current_epoch)
+                .sign_attestations(vec![(public_key, 0, attestation.clone())])
                 .await
                 .unwrap();
+            assert_eq!(safe_attestations.len(), 1);
+            // Compare data only, ignoring signatures which are added during signing.
+            assert_eq!(safe_attestations[0].data(), attestation.data());
+            // Check that the signature is non-zero.
+            assert!(!safe_attestations[0].signature().is_infinity());
         }
 
         // Delete the selected keys from VC1.
@@ -1178,16 +1182,28 @@ async fn generic_migration_test(
         check_keystore_import_response(&import_res, all_imported(import_indices.len()));
 
         // Sign attestations on the second VC.
-        for (validator_index, mut attestation, should_succeed) in second_vc_attestations {
+        for (validator_index, attestation, should_succeed) in second_vc_attestations {
             let public_key = keystore_pubkey(&keystores[validator_index]);
-            let current_epoch = attestation.data().target.epoch;
-            match tester2
+            let result = tester2
                 .validator_store
-                .sign_attestation(public_key, 0, &mut attestation, current_epoch)
-                .await
-            {
-                Ok(()) => assert!(should_succeed),
-                Err(e) => assert!(!should_succeed, "{:?}", e),
+                .sign_attestations(vec![(public_key, 0, attestation.clone())])
+                .await;
+            match result {
+                Ok(safe_attestations) => {
+                    if should_succeed {
+                        // Compare data only, ignoring signatures which are added during signing.
+                        assert_eq!(safe_attestations.len(), 1);
+                        assert_eq!(safe_attestations[0].data(), attestation.data());
+                        // Check that the signature is non-zero.
+                        assert!(!safe_attestations[0].signature().is_infinity());
+                    } else {
+                        assert!(safe_attestations.is_empty());
+                    }
+                }
+                Err(_) => {
+                    // Doppelganger protected or other error.
+                    assert!(!should_succeed);
+                }
             }
         }
     })
@@ -1313,10 +1329,10 @@ async fn delete_concurrent_with_signing() {
 
         let handle = handle.spawn(async move {
             for j in 0..num_attestations {
-                let mut att = make_attestation(j, j + 1);
+                let att = make_attestation(j, j + 1);
                 for public_key in thread_pubkeys.iter() {
                     let _ = validator_store
-                        .sign_attestation(*public_key, 0, &mut att, Epoch::new(j + 1))
+                        .sign_attestations(vec![(*public_key, 0, att.clone())])
                         .await;
                 }
             }

validator_client/lighthouse_validator_store/Cargo.toml

@@ -12,6 +12,7 @@ doppelganger_service = { workspace = true }
 either = { workspace = true }
 environment = { workspace = true }
 eth2 = { workspace = true }
+futures = { workspace = true }
 initialized_validators = { workspace = true }
 logging = { workspace = true }
 parking_lot = { workspace = true }