mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-16 19:32:55 +00:00
1d278aaa83
## Issue Addressed Implements support for importing and exporting the slashing protection DB interchange format described here: https://hackmd.io/@sproul/Bk0Y0qdGD Also closes #1584 ## Proposed Changes * [x] Support for serializing and deserializing the format * [x] Support for importing and exporting Lighthouse's database * [x] CLI commands to invoke import and export * [x] Export to minimal format (required when a minimal format has been previously imported) * [x] Tests for export to minimal (utilising mixed importing and attestation signing?) * [x] Tests for import/export of complete format, and import of minimal format * [x] ~~Prevent attestations with sources less than our max source (Danny's suggestion). Required for the fake attestation that we put in for the minimal format to block attestations from source 0.~~ * [x] Add the concept of a "low watermark" for compatibility with the minimal format Bonus! * [x] A fix to a potentially nasty bug involving validators getting re-registered each time the validator client ran! Thankfully, the ordering of keys meant that the validator IDs used for attestations and blocks remained stable -- otherwise we could have had some slashings on our hands! 😱 * [x] Tests to confirm that this bug is indeed vanquished
84 lines
2.4 KiB
Rust
84 lines
2.4 KiB
Rust
mod attestation_tests;
|
|
mod block_tests;
|
|
pub mod interchange;
|
|
pub mod interchange_test;
|
|
mod parallel_tests;
|
|
mod registration_tests;
|
|
mod signed_attestation;
|
|
mod signed_block;
|
|
mod slashing_database;
|
|
pub mod test_utils;
|
|
|
|
pub use crate::signed_attestation::{InvalidAttestation, SignedAttestation};
|
|
pub use crate::signed_block::{InvalidBlock, SignedBlock};
|
|
pub use crate::slashing_database::{SlashingDatabase, SUPPORTED_INTERCHANGE_FORMAT_VERSION};
|
|
use rusqlite::Error as SQLError;
|
|
use std::io::{Error as IOError, ErrorKind};
|
|
use std::string::ToString;
|
|
use types::{Hash256, PublicKey};
|
|
|
|
/// The filename within the `validators` directory that contains the slashing protection DB.
|
|
pub const SLASHING_PROTECTION_FILENAME: &str = "slashing_protection.sqlite";
|
|
|
|
/// The attestation or block is not safe to sign.
|
|
///
|
|
/// This could be because it's slashable, or because an error occurred.
|
|
#[derive(PartialEq, Debug)]
|
|
pub enum NotSafe {
|
|
UnregisteredValidator(PublicKey),
|
|
InvalidBlock(InvalidBlock),
|
|
InvalidAttestation(InvalidAttestation),
|
|
IOError(ErrorKind),
|
|
SQLError(String),
|
|
SQLPoolError(String),
|
|
}
|
|
|
|
/// The attestation or block is safe to sign, and will not cause the signer to be slashed.
|
|
#[derive(PartialEq, Debug)]
|
|
pub enum Safe {
|
|
/// Casting the exact same data (block or attestation) twice is never slashable.
|
|
SameData,
|
|
/// Incoming data is safe from slashing, and is not a duplicate.
|
|
Valid,
|
|
}
|
|
|
|
/// Safely parse a `Hash256` from the given `column` of an SQLite `row`.
|
|
fn hash256_from_row(column: usize, row: &rusqlite::Row) -> rusqlite::Result<Hash256> {
|
|
use rusqlite::{types::Type, Error};
|
|
|
|
let bytes: Vec<u8> = row.get(column)?;
|
|
if bytes.len() == 32 {
|
|
Ok(Hash256::from_slice(&bytes))
|
|
} else {
|
|
Err(Error::FromSqlConversionFailure(
|
|
column,
|
|
Type::Blob,
|
|
Box::from(format!("Invalid length for Hash256: {}", bytes.len())),
|
|
))
|
|
}
|
|
}
|
|
|
|
impl From<IOError> for NotSafe {
|
|
fn from(error: IOError) -> NotSafe {
|
|
NotSafe::IOError(error.kind())
|
|
}
|
|
}
|
|
|
|
impl From<SQLError> for NotSafe {
|
|
fn from(error: SQLError) -> NotSafe {
|
|
NotSafe::SQLError(error.to_string())
|
|
}
|
|
}
|
|
|
|
impl From<r2d2::Error> for NotSafe {
|
|
fn from(error: r2d2::Error) -> Self {
|
|
NotSafe::SQLPoolError(format!("{:?}", error))
|
|
}
|
|
}
|
|
|
|
impl ToString for NotSafe {
|
|
fn to_string(&self) -> String {
|
|
format!("{:?}", self)
|
|
}
|
|
}
|