Implement Slashing Protection (#1116)

* Implement slashing protection

Roll-up of #588 with some conflicts resolved

* WIP improvements

* Require slot uniqueness for blocks (rather than epochs)
* Native DB support for Slot and Epoch
* Simplify surrounding/surrounded-by queries

* Implement unified slashing protection database

A single SQL database saves on open file descriptors.

* Make slashing protection concurrency safe.

Revive tests, add parallel tests.

* Some simplifications

* Auto-registration, test clean-ups

* More tests, clean-ups, hardening

* Fix comments in BLS

* Optimise bulk validator registration

* Delete outdated tests

* Use bundled SQLite in slashing protection

* Auto-register validators in simulation

* Use real signing_root in slashing protection

* Update book for --auto-register

* Refine log messages and help flags

* Correct typo in Cargo.toml authors

* Fix merge conflicts

* Safer error handling in sqlite slot/epoch

* Address review comments

* Add attestation test mutating block root

Co-authored-by: pscott <scottpiriou@gmail.com>

validator_client/slashing_protection/src/parallel_tests.rs

@@ -0,0 +1,82 @@
+//! Tests that stress the concurrency safety of the slashing protection DB.
+#![cfg(test)]
+
+use crate::attestation_tests::attestation_data_builder;
+use crate::block_tests::block;
+use crate::test_utils::*;
+use crate::*;
+use rayon::prelude::*;
+use tempfile::tempdir;
+
+#[test]
+fn block_same_slot() {
+    let dir = tempdir().unwrap();
+    let slashing_db_file = dir.path().join("slashing_protection.sqlite");
+    let slashing_db = SlashingDatabase::create(&slashing_db_file).unwrap();
+
+    let pk = pubkey(0);
+
+    slashing_db.register_validator(&pk).unwrap();
+
+    // A stream of blocks all with the same slot.
+    let num_blocks = 10;
+    let results = (0..num_blocks)
+        .into_par_iter()
+        .map(|_| slashing_db.check_and_insert_block_proposal(&pk, &block(1), DEFAULT_DOMAIN))
+        .collect::<Vec<_>>();
+
+    let num_successes = results.iter().filter(|res| res.is_ok()).count();
+    assert_eq!(num_successes, 1);
+}
+
+#[test]
+fn attestation_same_target() {
+    let dir = tempdir().unwrap();
+    let slashing_db_file = dir.path().join("slashing_protection.sqlite");
+    let slashing_db = SlashingDatabase::create(&slashing_db_file).unwrap();
+
+    let pk = pubkey(0);
+
+    slashing_db.register_validator(&pk).unwrap();
+
+    // A stream of attestations all with the same target.
+    let num_attestations = 10;
+    let results = (0..num_attestations)
+        .into_par_iter()
+        .map(|i| {
+            slashing_db.check_and_insert_attestation(
+                &pk,
+                &attestation_data_builder(i, num_attestations),
+                DEFAULT_DOMAIN,
+            )
+        })
+        .collect::<Vec<_>>();
+
+    let num_successes = results.iter().filter(|res| res.is_ok()).count();
+    assert_eq!(num_successes, 1);
+}
+
+#[test]
+fn attestation_surround_fest() {
+    let dir = tempdir().unwrap();
+    let slashing_db_file = dir.path().join("slashing_protection.sqlite");
+    let slashing_db = SlashingDatabase::create(&slashing_db_file).unwrap();
+
+    let pk = pubkey(0);
+
+    slashing_db.register_validator(&pk).unwrap();
+
+    // A stream of attestations that all surround each other.
+    let num_attestations = 10;
+
+    let results = (0..num_attestations)
+        .into_par_iter()
+        .map(|i| {
+            let att = attestation_data_builder(i, 2 * num_attestations - i);
+            slashing_db.check_and_insert_attestation(&pk, &att, DEFAULT_DOMAIN)
+        })
+        .collect::<Vec<_>>();
+
+    let num_successes = results.iter().filter(|res| res.is_ok()).count();
+    assert_eq!(num_successes, 1);
+}