mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-10 04:01:51 +00:00
f3fd1f210b
There are certain crates which we re-export within `types` which creates a fragmented DevEx, where there are various ways to import the same crates.
```rust
// consensus/types/src/lib.rs
pub use bls::{
AggregatePublicKey, AggregateSignature, Error as BlsError, Keypair, PUBLIC_KEY_BYTES_LEN,
PublicKey, PublicKeyBytes, SIGNATURE_BYTES_LEN, SecretKey, Signature, SignatureBytes,
get_withdrawal_credentials,
};
pub use context_deserialize::{ContextDeserialize, context_deserialize};
pub use fixed_bytes::FixedBytesExtended;
pub use milhouse::{self, List, Vector};
pub use ssz_types::{BitList, BitVector, FixedVector, VariableList, typenum, typenum::Unsigned};
pub use superstruct::superstruct;
```
This PR removes these re-exports and makes it explicit that these types are imported from a non-`consensus/types` crate.
Co-Authored-By: Mac L <mjladson@pm.me>
77 lines
2.4 KiB
Rust
77 lines
2.4 KiB
Rust
#![cfg(test)]
|
|
|
|
use crate::test_utils::pubkey;
|
|
use crate::*;
|
|
use fixed_bytes::FixedBytesExtended;
|
|
use tempfile::tempdir;
|
|
|
|
#[test]
|
|
fn export_non_existent_key() {
|
|
let dir = tempdir().unwrap();
|
|
let slashing_db_file = dir.path().join("slashing_protection.sqlite");
|
|
let slashing_db = SlashingDatabase::create(&slashing_db_file).unwrap();
|
|
|
|
let key1 = pubkey(1);
|
|
let key2 = pubkey(2);
|
|
|
|
// Exporting two non-existent keys should fail on the first one.
|
|
let err = slashing_db
|
|
.export_interchange_info(Hash256::zero(), Some(&[key1, key2]))
|
|
.unwrap_err();
|
|
assert!(matches!(
|
|
err,
|
|
InterchangeError::NotSafe(NotSafe::UnregisteredValidator(k)) if k == key1
|
|
));
|
|
|
|
slashing_db.register_validator(key1).unwrap();
|
|
|
|
// Exporting one key that exists and one that doesn't should fail on the one that doesn't.
|
|
let err = slashing_db
|
|
.export_interchange_info(Hash256::zero(), Some(&[key1, key2]))
|
|
.unwrap_err();
|
|
assert!(matches!(
|
|
err,
|
|
InterchangeError::NotSafe(NotSafe::UnregisteredValidator(k)) if k == key2
|
|
));
|
|
|
|
// Exporting only keys that exist should work.
|
|
let interchange = slashing_db
|
|
.export_interchange_info(Hash256::zero(), Some(&[key1]))
|
|
.unwrap();
|
|
assert_eq!(interchange.data.len(), 1);
|
|
assert_eq!(interchange.data[0].pubkey, key1);
|
|
}
|
|
|
|
#[test]
|
|
fn export_same_key_twice() {
|
|
let dir = tempdir().unwrap();
|
|
let slashing_db_file = dir.path().join("slashing_protection.sqlite");
|
|
let slashing_db = SlashingDatabase::create(&slashing_db_file).unwrap();
|
|
|
|
let key1 = pubkey(1);
|
|
|
|
slashing_db.register_validator(key1).unwrap();
|
|
|
|
let export_single = slashing_db
|
|
.export_interchange_info(Hash256::zero(), Some(&[key1]))
|
|
.unwrap();
|
|
let export_double = slashing_db
|
|
.export_interchange_info(Hash256::zero(), Some(&[key1, key1]))
|
|
.unwrap();
|
|
|
|
assert_eq!(export_single.data.len(), 1);
|
|
|
|
// Allow the same data to be exported twice, this is harmless, albeit slightly inefficient.
|
|
assert_eq!(export_double.data.len(), 2);
|
|
assert_eq!(export_double.data[0], export_double.data[1]);
|
|
|
|
// The data should be identical to the single export.
|
|
assert_eq!(export_double.data[0], export_single.data[0]);
|
|
|
|
// The minified versions should be equal too.
|
|
assert_eq!(
|
|
export_single.minify().unwrap(),
|
|
export_double.minify().unwrap()
|
|
);
|
|
}
|