Batch attestation slashibility checking

beacon_node/http_api/tests/tests.rs

@@ -1862,7 +1862,7 @@ impl ApiTester {
 
     pub async fn test_post_beacon_pool_attestations_valid(mut self) -> Self {
         self.client
-            .post_beacon_pool_attestations_v1(self.attestations.as_slice())
+            .post_beacon_pool_attestations_v1(&self.attestations)
             .await
             .unwrap();
 
@@ -1923,7 +1923,7 @@ impl ApiTester {
 
         let err = self
             .client
-            .post_beacon_pool_attestations_v1(attestations.as_slice())
+            .post_beacon_pool_attestations_v1(&attestations)
             .await
             .unwrap_err();
 
@@ -4062,7 +4062,7 @@ impl ApiTester {
 
         // Attest to the current slot
         self.client
-            .post_beacon_pool_attestations_v1(self.attestations.as_slice())
+            .post_beacon_pool_attestations_v1(&self.attestations)
             .await
             .unwrap();
 
@@ -5801,7 +5801,7 @@ impl ApiTester {
 
         // Attest to the current slot
         self.client
-            .post_beacon_pool_attestations_v1(self.attestations.as_slice())
+            .post_beacon_pool_attestations_v1(&self.attestations)
             .await
             .unwrap();
 
@@ -5857,7 +5857,7 @@ impl ApiTester {
         let expected_attestation_len = self.attestations.len();
 
         self.client
-            .post_beacon_pool_attestations_v1(self.attestations.as_slice())
+            .post_beacon_pool_attestations_v1(&self.attestations)
             .await
             .unwrap();
 

testing/web3signer_tests/src/lib.rs

@@ -28,6 +28,7 @@ mod tests {
     use parking_lot::Mutex;
     use reqwest::Client;
     use serde::Serialize;
+    use slashing_protection::NotSafe;
     use slashing_protection::{SlashingDatabase, SLASHING_PROTECTION_FILENAME};
     use slot_clock::{SlotClock, TestingSlotClock};
     use std::env;
@@ -838,9 +839,29 @@ mod tests {
             "double_vote_attestation",
             move |pubkey, validator_store| async move {
                 let mut attestation = double_vote_attestation();
+
                 validator_store
                     .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
                     .await
+                    .unwrap();
+
+                let safe_attestations = validator_store
+                    .check_and_insert_attestations(vec![(attestation, pubkey)])
+                    .unwrap();
+
+                if !slashable_message_should_sign && !safe_attestations.is_empty() {
+                    // if slashability checks are disabled and we don't return any safe attestations
+                    // we raise an error to indicate that thi test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                if slashable_message_should_sign && safe_attestations.is_empty() {
+                    // if slashability checks are en    abled and we return safe attestations
+                    // we raise an error to indicate that this test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                Ok(())
             },
             slashable_message_should_sign,
         )
@@ -849,9 +870,29 @@ mod tests {
             "surrounding_attestation",
             move |pubkey, validator_store| async move {
                 let mut attestation = surrounding_attestation();
+
                 validator_store
                     .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
                     .await
+                    .unwrap();
+
+                let safe_attestations = validator_store
+                    .check_and_insert_attestations(vec![(attestation, pubkey)])
+                    .unwrap();
+
+                if !slashable_message_should_sign && !safe_attestations.is_empty() {
+                    // if slashability checks are disabled and we don't return any safe attestations
+                    // we raise an error to indicate that thi test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                if slashable_message_should_sign && safe_attestations.is_empty() {
+                    // if slashability checks are eabled and we return safe attestations
+                    // we raise an error to indicate that this test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                Ok(())
             },
             slashable_message_should_sign,
         )
@@ -860,9 +901,29 @@ mod tests {
             "surrounded_attestation",
             move |pubkey, validator_store| async move {
                 let mut attestation = surrounded_attestation();
+
                 validator_store
                     .sign_attestation(pubkey, 0, &mut attestation, current_epoch)
                     .await
+                    .unwrap();
+
+                let safe_attestations = validator_store
+                    .check_and_insert_attestations(vec![(attestation, pubkey)])
+                    .unwrap();
+
+                if !slashable_message_should_sign && !safe_attestations.is_empty() {
+                    // if slashability checks are disabled and we don't return any safe attestations
+                    // we raise an error to indicate that thi test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                if slashable_message_should_sign && safe_attestations.is_empty() {
+                    // if slashability checks are eabled and we return safe attestations
+                    // we raise an error to indicate that this test case has failed
+                    return Err(ValidatorStoreError::Slashable(NotSafe::ConsistencyError));
+                }
+
+                Ok(())
             },
             slashable_message_should_sign,
         )

validator_client/http_api/src/tests/keystores.rs

@@ -7,12 +7,14 @@ use eth2::lighthouse_vc::{
     std_types::{KeystoreJsonStr as Keystore, *},
     types::Web3SignerValidatorRequest,
 };
+use eth2::types::AttesterData;
 use itertools::Itertools;
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use slashing_protection::interchange::{Interchange, InterchangeMetadata};
 use std::{collections::HashMap, path::Path};
 use tokio::runtime::Handle;
 use types::{attestation::AttestationBase, Address};
+use validator_services::duties_service::DutyAndProof;
 use validator_store::DEFAULT_GAS_LIMIT;
 use zeroize::Zeroizing;
 
@@ -1092,17 +1094,53 @@ async fn generic_migration_test(
             .unwrap();
         check_keystore_import_response(&import_res, all_imported(keystores.len()));
 
+        let attestations_and_duties = first_vc_attestations
+            .into_iter()
+            .map(|(validator_index, attestation)| {
+                (
+                    attestation.clone(),
+                    DutyAndProof::new_without_selection_proof(
+                        AttesterData {
+                            pubkey: keystore_pubkey(&keystores[validator_index]),
+                            validator_index: validator_index as u64,
+                            committees_at_slot: 0,
+                            committee_index: 0,
+                            committee_length: 0,
+                            validator_committee_index: 0,
+                            slot: attestation.data().slot,
+                        },
+                        attestation.data().slot,
+                    ),
+                )
+            })
+            .collect::<Vec<_>>();
+
         // Sign attestations on VC1.
-        for (validator_index, mut attestation) in first_vc_attestations {
-            let public_key = keystore_pubkey(&keystores[validator_index]);
+        for (mut attestation, validator_duty) in attestations_and_duties.clone() {
             let current_epoch = attestation.data().target.epoch;
             tester1
                 .validator_store
-                .sign_attestation(public_key, 0, &mut attestation, current_epoch)
+                .sign_attestation(
+                    validator_duty.duty.pubkey,
+                    0,
+                    &mut attestation,
+                    current_epoch,
+                )
                 .await
                 .unwrap();
         }
 
+        tester1
+            .validator_store
+            .check_and_insert_attestations(
+                attestations_and_duties
+                    .clone()
+                    .into_iter()
+                    .map(|(a, b)| (a.clone(), b.duty.pubkey))
+                    .collect::<Vec<_>>(),
+            )
+            .unwrap();
+
         // Delete the selected keys from VC1.
         let delete_res = tester1
             .client
@@ -1115,6 +1153,7 @@ async fn generic_migration_test(
             })
             .await
             .unwrap();
+
         check_keystore_delete_response(&delete_res, all_deleted(delete_indices.len()));
 
         // Check that slashing protection data was returned for all selected validators.
@@ -1168,17 +1207,70 @@ async fn generic_migration_test(
             .unwrap();
         check_keystore_import_response(&import_res, all_imported(import_indices.len()));
 
+        let attestations_and_duties = second_vc_attestations
+            .into_iter()
+            .map(|(validator_index, attestation, should_succeed)| {
+                (
+                    attestation.clone(),
+                    DutyAndProof::new_without_selection_proof(
+                        AttesterData {
+                            pubkey: keystore_pubkey(&keystores[validator_index]),
+                            validator_index: validator_index as u64,
+                            committees_at_slot: 0,
+                            committee_index: 0,
+                            committee_length: 0,
+                            validator_committee_index: 0,
+                            slot: attestation.data().slot,
+                        },
+                        attestation.data().slot,
+                    ),
+                    should_succeed,
+                )
+            })
+            .collect::<Vec<_>>();
+
         // Sign attestations on the second VC.
-        for (validator_index, mut attestation, should_succeed) in second_vc_attestations {
-            let public_key = keystore_pubkey(&keystores[validator_index]);
+        for (mut attestation, validator_duty, should_succeed) in attestations_and_duties.clone() {
             let current_epoch = attestation.data().target.epoch;
+
             match tester2
                 .validator_store
-                .sign_attestation(public_key, 0, &mut attestation, current_epoch)
+                .sign_attestation(
+                    validator_duty.duty.pubkey,
+                    0,
+                    &mut attestation,
+                    current_epoch,
+                )
                 .await
             {
-                Ok(()) => assert!(should_succeed),
-                Err(e) => assert!(!should_succeed, "{:?}", e),
+                Ok(_) => (),
+                Err(_) => {
+                    if should_succeed {
+                        panic!("Should succeed");
+                    } else {
+                        continue;
+                    }
+                }
+            };
+
+            let attestation_and_duty = vec![(attestation, validator_duty)];
+
+            let Ok(safe_attestation) = tester2.validator_store.check_and_insert_attestations(
+                attestation_and_duty
+                    .clone()
+                    .into_iter()
+                    .map(|(a, b)| (a.clone(), b.duty.pubkey))
+                    .collect::<Vec<_>>(),
+            ) else {
+                panic!("Should succeed");
+            };
+
+            if !safe_attestation.is_empty() && !should_succeed {
+                panic!("should fail")
+            }
+
+            if safe_attestation.is_empty() && should_succeed {
+                panic!("should succeed")
             }
         }
     })

validator_client/slashing_protection/src/interchange_test.rs

@@ -3,6 +3,7 @@ use crate::{
     test_utils::{pubkey, DEFAULT_GENESIS_VALIDATORS_ROOT},
     SigningRoot, SlashingDatabase,
 };
+use rusqlite::TransactionBehavior;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use tempfile::tempdir;
@@ -132,12 +133,18 @@ impl MultiTestCase {
                 }
             }
 
+            let mut conn = slashing_db.get_db_connection().unwrap();
+            let txn = conn
+                .transaction_with_behavior(TransactionBehavior::Exclusive)
+                .unwrap();
+
             for (i, att) in test_case.attestations.iter().enumerate() {
                 match slashing_db.check_and_insert_attestation_signing_root(
                     &att.pubkey,
                     att.source_epoch,
                     att.target_epoch,
                     SigningRoot::from(att.signing_root),
+                    &txn,
                 ) {
                     Ok(safe) if !att.should_succeed => {
                         panic!(
@@ -154,6 +161,8 @@ impl MultiTestCase {
                     _ => (),
                 }
             }
+
+            slashing_db.commit(txn).unwrap();
         }
     }
 }

validator_client/slashing_protection/src/parallel_tests.rs

@@ -6,6 +6,7 @@ use crate::block_tests::block;
 use crate::test_utils::*;
 use crate::*;
 use rayon::prelude::*;
+use rusqlite::TransactionBehavior;
 use tempfile::tempdir;
 
 #[test]
@@ -44,11 +45,18 @@ fn attestation_same_target() {
     let results = (0..num_attestations)
         .into_par_iter()
         .map(|i| {
-            slashing_db.check_and_insert_attestation(
+            let mut conn = slashing_db.get_db_connection().unwrap();
+            let txn = conn
+                .transaction_with_behavior(TransactionBehavior::Exclusive)
+                .unwrap();
+            let result = slashing_db.check_and_insert_attestation(
                 &pk,
                 &attestation_data_builder(i, num_attestations),
                 DEFAULT_DOMAIN,
-            )
+                &txn,
+            );
+            slashing_db.commit(txn).unwrap();
+            result
         })
         .collect::<Vec<_>>();
 
@@ -72,8 +80,14 @@ fn attestation_surround_fest() {
     let results = (0..num_attestations)
         .into_par_iter()
         .map(|i| {
+            let mut conn = slashing_db.get_db_connection().unwrap();
+            let txn = conn
+                .transaction_with_behavior(TransactionBehavior::Exclusive)
+                .unwrap();
             let att = attestation_data_builder(i, 2 * num_attestations - i);
-            slashing_db.check_and_insert_attestation(&pk, &att, DEFAULT_DOMAIN)
+            let result = slashing_db.check_and_insert_attestation(&pk, &att, DEFAULT_DOMAIN, &txn);
+            slashing_db.commit(txn).unwrap();
+            result
         })
         .collect::<Vec<_>>();