From bfa2e71b468e34eedcf847076aa29f3a53038bfd Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Wed, 13 Mar 2019 14:41:43 +1100 Subject: [PATCH 1/5] Move `PublicKey` to store uncompressed bytes. This is an optimisation that allows for faster hashing of a public key, however it adds a penalty to SSZ encoding because we need to go decompressed -> PublicKey -> compressed. The spec presently uses compressed bytes to store public keys, however I'm hoping it will change. --- eth2/utils/bls/src/aggregate_public_key.rs | 2 +- eth2/utils/bls/src/public_key.rs | 56 ++++++++++++++++------ eth2/utils/bls/src/signature.rs | 4 +- 3 files changed, 44 insertions(+), 18 deletions(-) diff --git a/eth2/utils/bls/src/aggregate_public_key.rs b/eth2/utils/bls/src/aggregate_public_key.rs index 2174a43cb..47c95d6c9 100644 --- a/eth2/utils/bls/src/aggregate_public_key.rs +++ b/eth2/utils/bls/src/aggregate_public_key.rs @@ -14,7 +14,7 @@ impl AggregatePublicKey { } pub fn add(&mut self, public_key: &PublicKey) { - self.0.add(public_key.as_raw()) + self.0.add(&public_key.as_raw()) } /// Returns the underlying signature. diff --git a/eth2/utils/bls/src/public_key.rs b/eth2/utils/bls/src/public_key.rs index c85760bbf..3e2bff19e 100644 --- a/eth2/utils/bls/src/public_key.rs +++ b/eth2/utils/bls/src/public_key.rs @@ -10,39 +10,58 @@ use ssz::{ use std::default; use std::hash::{Hash, Hasher}; -/// A single BLS signature. +/// A single BLS public key. +/// +/// This struct stores an uncompressed public key as a byte vec. The reason we store bytes instead +/// of the `RawPublicKey` struct is because it allows for building a hashmap of `PublicKey` much +/// faster. +/// +/// Storing as uncompressed bytes costs ~0.02% more time when adding a `PublicKey` to an +/// `AggregateKey`, however it saves ~0.5ms each time you need to add a pubkey to a hashmap. /// /// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ /// serialization). #[derive(Debug, Clone, Eq)] -pub struct PublicKey(RawPublicKey); +pub struct PublicKey { + bytes: Vec, +} impl PublicKey { pub fn from_secret_key(secret_key: &SecretKey) -> Self { - PublicKey(RawPublicKey::from_secret_key(secret_key.as_raw())) + let mut raw_key = RawPublicKey::from_secret_key(secret_key.as_raw()); + let uncompressed_bytes = raw_key.as_uncompressed_bytes(); + Self { + bytes: uncompressed_bytes, + } } /// Returns the underlying signature. - pub fn as_raw(&self) -> &RawPublicKey { - &self.0 + pub fn as_raw(&self) -> RawPublicKey { + RawPublicKey::from_uncompressed_bytes(&self.bytes).expect("PublicKey in invalid state") } /// Converts compressed bytes to PublicKey pub fn from_bytes(bytes: &[u8]) -> Result { - let pubkey = RawPublicKey::from_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; - Ok(PublicKey(pubkey)) + let mut pubkey = RawPublicKey::from_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; + Ok(Self { + bytes: pubkey.as_uncompressed_bytes(), + }) } /// Returns the PublicKey as (x, y) bytes pub fn as_uncompressed_bytes(&self) -> Vec { - RawPublicKey::as_uncompressed_bytes(&mut self.0.clone()) + self.bytes.clone() } /// Converts (x, y) bytes to PublicKey pub fn from_uncompressed_bytes(bytes: &[u8]) -> Result { - let pubkey = + // Do a conversion to check the bytes are valid. + let _pubkey = RawPublicKey::from_uncompressed_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; - Ok(PublicKey(pubkey)) + + Ok(Self { + bytes: bytes.to_vec(), + }) } /// Returns the last 6 bytes of the SSZ encoding of the public key, as a hex string. @@ -64,15 +83,22 @@ impl default::Default for PublicKey { impl Encodable for PublicKey { fn ssz_append(&self, s: &mut SszStream) { - s.append_vec(&self.0.as_bytes()); + s.append_vec(&self.as_raw().as_bytes()); } } impl Decodable for PublicKey { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (sig_bytes, i) = decode_ssz_list(bytes, i)?; - let raw_sig = RawPublicKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?; - Ok((PublicKey(raw_sig), i)) + let mut raw_sig = + RawPublicKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?; + + Ok(( + Self { + bytes: raw_sig.as_uncompressed_bytes(), + }, + i, + )) } } @@ -99,7 +125,7 @@ impl<'de> Deserialize<'de> for PublicKey { impl TreeHash for PublicKey { fn hash_tree_root(&self) -> Vec { - hash(&self.0.as_bytes()) + hash(&self.as_raw().as_bytes()) } } @@ -117,7 +143,7 @@ impl Hash for PublicKey { /// /// Use `ssz::Encode` to obtain the bytes required for consensus hashing. fn hash(&self, state: &mut H) { - self.as_uncompressed_bytes().hash(state) + self.bytes.hash(state) } } diff --git a/eth2/utils/bls/src/signature.rs b/eth2/utils/bls/src/signature.rs index 47598bc66..47e1dad2e 100644 --- a/eth2/utils/bls/src/signature.rs +++ b/eth2/utils/bls/src/signature.rs @@ -33,7 +33,7 @@ impl Signature { /// Verify the Signature against a PublicKey. pub fn verify(&self, msg: &[u8], domain: u64, pk: &PublicKey) -> bool { - self.0.verify(msg, domain, pk.as_raw()) + self.0.verify(msg, domain, &pk.as_raw()) } /// Verify the Signature against a PublicKey, where the message has already been hashed. @@ -44,7 +44,7 @@ impl Signature { pk: &PublicKey, ) -> bool { self.0 - .verify_hashed(x_real_hashed, x_imaginary_hashed, pk.as_raw()) + .verify_hashed(x_real_hashed, x_imaginary_hashed, &pk.as_raw()) } /// Returns the underlying signature. From 6cd3c4bd1a6531009a16a2a1894ff7c70636d5d8 Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Wed, 13 Mar 2019 16:40:28 +1100 Subject: [PATCH 2/5] Add a cache for public keys to BeaconState This allows for a fast lookup of "is this public key already in the validator registry". --- eth2/state_processing/benches/benches.rs | 5 +- .../src/per_block_processing.rs | 9 ++-- .../src/per_block_processing/errors.rs | 5 +- .../per_block_processing/verify_deposit.rs | 7 +-- eth2/types/src/beacon_state.rs | 46 +++++++++++++++++++ eth2/types/src/beacon_state/pubkey_cache.rs | 45 ++++++++++++++++++ eth2/types/src/lib.rs | 3 +- .../testing_beacon_state_builder.rs | 2 + 8 files changed, 109 insertions(+), 13 deletions(-) create mode 100644 eth2/types/src/beacon_state/pubkey_cache.rs diff --git a/eth2/state_processing/benches/benches.rs b/eth2/state_processing/benches/benches.rs index ad8c4f714..4de97a298 100644 --- a/eth2/state_processing/benches/benches.rs +++ b/eth2/state_processing/benches/benches.rs @@ -1,14 +1,11 @@ -use criterion::Benchmark; use criterion::Criterion; use criterion::{criterion_group, criterion_main}; use env_logger::{Builder, Env}; -use types::test_utils::TestingBeaconStateBuilder; -use types::*; mod bench_block_processing; mod bench_epoch_processing; -pub const VALIDATOR_COUNT: usize = 300_032; +pub const VALIDATOR_COUNT: usize = 16_384; // `LOG_LEVEL == "debug"` gives logs, but they're very noisy and slow down benching. pub const LOG_LEVEL: &str = ""; diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs index 7b5aafa7f..13a47836b 100644 --- a/eth2/state_processing/src/per_block_processing.rs +++ b/eth2/state_processing/src/per_block_processing.rs @@ -373,19 +373,20 @@ pub fn process_deposits( .map_err(|e| e.into_with_index(i)) })?; - let public_key_to_index_hashmap = build_public_key_hashmap(&state); - // Check `state.deposit_index` and update the state in series. for (i, deposit) in deposits.iter().enumerate() { verify_deposit_index(state, deposit).map_err(|e| e.into_with_index(i))?; + // Ensure the state's pubkey cache is fully up-to-date, it will be used to check to see if the + // depositing validator already exists in the registry. + state.update_pubkey_cache()?; + // Get an `Option` where `u64` is the validator index if this deposit public key // already exists in the beacon_state. // // This function also verifies the withdrawal credentials. let validator_index = - get_existing_validator_index(state, deposit, &public_key_to_index_hashmap) - .map_err(|e| e.into_with_index(i))?; + get_existing_validator_index(state, deposit).map_err(|e| e.into_with_index(i))?; let deposit_data = &deposit.deposit_data; let deposit_input = &deposit.deposit_data.deposit_input; diff --git a/eth2/state_processing/src/per_block_processing/errors.rs b/eth2/state_processing/src/per_block_processing/errors.rs index a3e3ebad1..8366a6584 100644 --- a/eth2/state_processing/src/per_block_processing/errors.rs +++ b/eth2/state_processing/src/per_block_processing/errors.rs @@ -294,6 +294,8 @@ impl_into_with_index_without_beacon_error!( pub enum DepositValidationError { /// Validation completed successfully and the object is invalid. Invalid(DepositInvalid), + /// Encountered a `BeaconStateError` whilst attempting to determine validity. + BeaconStateError(BeaconStateError), } /// Describes why an object is invalid. @@ -313,7 +315,8 @@ pub enum DepositInvalid { BadMerkleProof, } -impl_into_with_index_without_beacon_error!(DepositValidationError, DepositInvalid); +impl_from_beacon_state_error!(DepositValidationError); +impl_into_with_index_with_beacon_error!(DepositValidationError, DepositInvalid); /* * `Exit` Validation diff --git a/eth2/state_processing/src/per_block_processing/verify_deposit.rs b/eth2/state_processing/src/per_block_processing/verify_deposit.rs index 1aabbb973..aad38f616 100644 --- a/eth2/state_processing/src/per_block_processing/verify_deposit.rs +++ b/eth2/state_processing/src/per_block_processing/verify_deposit.rs @@ -72,11 +72,12 @@ pub fn build_public_key_hashmap(state: &BeaconState) -> PublicKeyValidatorIndexH pub fn get_existing_validator_index( state: &BeaconState, deposit: &Deposit, - pubkey_map: &HashMap, ) -> Result, Error> { let deposit_input = &deposit.deposit_data.deposit_input; - let validator_index = pubkey_map.get(&deposit_input.pubkey).and_then(|i| Some(*i)); + let validator_index = state + .get_validator_index(&deposit_input.pubkey)? + .and_then(|i| Some(i)); match validator_index { None => Ok(None), @@ -86,7 +87,7 @@ pub fn get_existing_validator_index( == state.validator_registry[index as usize].withdrawal_credentials, Invalid::BadWithdrawalCredentials ); - Ok(Some(index)) + Ok(Some(index as u64)) } } } diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs index 878d13b86..fc410fe64 100644 --- a/eth2/types/src/beacon_state.rs +++ b/eth2/types/src/beacon_state.rs @@ -5,6 +5,7 @@ use helpers::*; use honey_badger_split::SplitExt; use int_to_bytes::int_to_bytes32; use log::{debug, error, trace}; +use pubkey_cache::PubkeyCache; use rand::RngCore; use serde_derive::Serialize; use ssz::{hash, Decodable, DecodeError, Encodable, SignedRoot, SszStream, TreeHash}; @@ -16,6 +17,7 @@ pub use builder::BeaconStateBuilder; mod builder; mod epoch_cache; pub mod helpers; +mod pubkey_cache; mod tests; pub type Committee = Vec; @@ -52,6 +54,11 @@ pub enum Error { InsufficientAttestations, InsufficientCommittees, EpochCacheUninitialized(RelativeEpoch), + PubkeyCacheInconsistent, + PubkeyCacheIncomplete { + cache_len: usize, + registry_len: usize, + }, } macro_rules! safe_add_assign { @@ -108,6 +115,7 @@ pub struct BeaconState { // Caching (not in the spec) pub cache_index_offset: usize, pub caches: Vec, + pub pubkey_cache: PubkeyCache, } impl BeaconState { @@ -186,6 +194,7 @@ impl BeaconState { */ cache_index_offset: 0, caches: vec![EpochCache::empty(); CACHED_EPOCHS], + pubkey_cache: PubkeyCache::empty(), } } @@ -293,6 +302,41 @@ impl BeaconState { } } + /// Updates the pubkey cache, if required. + /// + /// Adds all `pubkeys` from the `validator_registry` which are not already in the cache. Will + /// never re-add a pubkey. + pub fn update_pubkey_cache(&mut self) -> Result<(), Error> { + for (i, validator) in self + .validator_registry + .iter() + .enumerate() + .skip(self.pubkey_cache.len()) + { + let success = self.pubkey_cache.insert(validator.pubkey.clone(), i); + if !success { + return Err(Error::PubkeyCacheInconsistent); + } + } + + Ok(()) + } + + /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise + /// returns `None`. + /// + /// Requires a fully up-to-date `pubkey_cache`, returns an error if this is not the case. + pub fn get_validator_index(&self, pubkey: &PublicKey) -> Result, Error> { + if self.pubkey_cache.len() == self.validator_registry.len() { + Ok(self.pubkey_cache.get(pubkey)) + } else { + Err(Error::PubkeyCacheIncomplete { + cache_len: self.pubkey_cache.len(), + registry_len: self.validator_registry.len(), + }) + } + } + /// The epoch corresponding to `self.slot`. /// /// Spec v0.4.0 @@ -1188,6 +1232,7 @@ impl Decodable for BeaconState { deposit_index, cache_index_offset: 0, caches: vec![EpochCache::empty(); CACHED_EPOCHS], + pubkey_cache: PubkeyCache::empty(), }, i, )) @@ -1258,6 +1303,7 @@ impl TestRandom for BeaconState { deposit_index: <_>::random_for_test(rng), cache_index_offset: 0, caches: vec![EpochCache::empty(); CACHED_EPOCHS], + pubkey_cache: PubkeyCache::empty(), } } } diff --git a/eth2/types/src/beacon_state/pubkey_cache.rs b/eth2/types/src/beacon_state/pubkey_cache.rs new file mode 100644 index 000000000..c05147579 --- /dev/null +++ b/eth2/types/src/beacon_state/pubkey_cache.rs @@ -0,0 +1,45 @@ +use crate::*; +use serde_derive::Serialize; +use std::collections::HashMap; + +type ValidatorIndex = usize; + +#[derive(Debug, PartialEq, Clone, Default, Serialize)] +pub struct PubkeyCache { + map: HashMap, +} + +impl PubkeyCache { + /// Instantiates a new, empty cache. + pub fn empty() -> Self { + Self { + map: HashMap::new(), + } + } + + /// Returns the number of validator indices already in the map. + pub fn len(&self) -> ValidatorIndex { + self.map.len() + } + + /// Inserts a validator index into the map. + /// + /// The added index must equal the number of validators already added to the map. This ensures + /// that an index is never skipped. + pub fn insert(&mut self, pubkey: PublicKey, index: ValidatorIndex) -> bool { + if index == self.map.len() { + self.map.insert(pubkey, index); + true + } else { + false + } + } + + /// Inserts a validator index into the map. + /// + /// The added index must equal the number of validators already added to the map. This ensures + /// that an index is never skipped. + pub fn get(&self, pubkey: &PublicKey) -> Option { + self.map.get(pubkey).cloned() + } +} diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs index 76fcb43ed..3da6a497f 100644 --- a/eth2/types/src/lib.rs +++ b/eth2/types/src/lib.rs @@ -1,4 +1,4 @@ -pub mod test_utils; +//! Ethereum 2.0 types pub mod attestation; pub mod attestation_data; @@ -22,6 +22,7 @@ pub mod proposer_slashing; pub mod readers; pub mod shard_reassignment_record; pub mod slashable_attestation; +pub mod test_utils; pub mod transfer; pub mod voluntary_exit; #[macro_use] diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs index b2cf28c8a..b9f3c63e0 100644 --- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs +++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs @@ -144,6 +144,8 @@ impl TestingBeaconStateBuilder { state.build_epoch_cache(RelativeEpoch::Current, &spec)?; state.build_epoch_cache(RelativeEpoch::Next, &spec)?; + state.update_pubkey_cache()?; + Ok(()) } From 587be831b57528eb016b1c66c0e3eb8679c74f04 Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Wed, 13 Mar 2019 16:49:32 +1100 Subject: [PATCH 3/5] Add method for dropping pubkey cache. Add bench. --- .../benches/bench_block_processing.rs | 17 +++++++++++++++++ eth2/types/src/beacon_state.rs | 5 +++++ 2 files changed, 22 insertions(+) diff --git a/eth2/state_processing/benches/bench_block_processing.rs b/eth2/state_processing/benches/bench_block_processing.rs index 031942473..128b1051b 100644 --- a/eth2/state_processing/benches/bench_block_processing.rs +++ b/eth2/state_processing/benches/bench_block_processing.rs @@ -426,6 +426,23 @@ fn bench_block_processing( .sample_size(10), ); + let mut state = initial_state.clone(); + state.drop_pubkey_cache(); + c.bench( + &format!("{}/block_processing", desc), + Benchmark::new("build_pubkey_cache", move |b| { + b.iter_batched( + || state.clone(), + |mut state| { + state.update_pubkey_cache().unwrap(); + state + }, + criterion::BatchSize::SmallInput, + ) + }) + .sample_size(10), + ); + let block = initial_block.clone(); c.bench( &format!("{}/block_processing", desc), diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs index fc410fe64..a1dd8983c 100644 --- a/eth2/types/src/beacon_state.rs +++ b/eth2/types/src/beacon_state.rs @@ -322,6 +322,11 @@ impl BeaconState { Ok(()) } + /// Completely drops the `pubkey_cache`, replacing it with a new, empty cache. + pub fn drop_pubkey_cache(&mut self) { + self.pubkey_cache = PubkeyCache::empty() + } + /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise /// returns `None`. /// From b2fb2afb2813c4288a462c4a84bf6bf9ea7f7528 Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Wed, 13 Mar 2019 16:51:37 +1100 Subject: [PATCH 4/5] Revert "Move `PublicKey` to store uncomp. bytes." This reverts commit bfa2e71b468e34eedcf847076aa29f3a53038bfd. --- eth2/utils/bls/src/aggregate_public_key.rs | 2 +- eth2/utils/bls/src/public_key.rs | 56 ++++++---------------- eth2/utils/bls/src/signature.rs | 4 +- 3 files changed, 18 insertions(+), 44 deletions(-) diff --git a/eth2/utils/bls/src/aggregate_public_key.rs b/eth2/utils/bls/src/aggregate_public_key.rs index 47c95d6c9..2174a43cb 100644 --- a/eth2/utils/bls/src/aggregate_public_key.rs +++ b/eth2/utils/bls/src/aggregate_public_key.rs @@ -14,7 +14,7 @@ impl AggregatePublicKey { } pub fn add(&mut self, public_key: &PublicKey) { - self.0.add(&public_key.as_raw()) + self.0.add(public_key.as_raw()) } /// Returns the underlying signature. diff --git a/eth2/utils/bls/src/public_key.rs b/eth2/utils/bls/src/public_key.rs index 3e2bff19e..c85760bbf 100644 --- a/eth2/utils/bls/src/public_key.rs +++ b/eth2/utils/bls/src/public_key.rs @@ -10,58 +10,39 @@ use ssz::{ use std::default; use std::hash::{Hash, Hasher}; -/// A single BLS public key. -/// -/// This struct stores an uncompressed public key as a byte vec. The reason we store bytes instead -/// of the `RawPublicKey` struct is because it allows for building a hashmap of `PublicKey` much -/// faster. -/// -/// Storing as uncompressed bytes costs ~0.02% more time when adding a `PublicKey` to an -/// `AggregateKey`, however it saves ~0.5ms each time you need to add a pubkey to a hashmap. +/// A single BLS signature. /// /// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ /// serialization). #[derive(Debug, Clone, Eq)] -pub struct PublicKey { - bytes: Vec, -} +pub struct PublicKey(RawPublicKey); impl PublicKey { pub fn from_secret_key(secret_key: &SecretKey) -> Self { - let mut raw_key = RawPublicKey::from_secret_key(secret_key.as_raw()); - let uncompressed_bytes = raw_key.as_uncompressed_bytes(); - Self { - bytes: uncompressed_bytes, - } + PublicKey(RawPublicKey::from_secret_key(secret_key.as_raw())) } /// Returns the underlying signature. - pub fn as_raw(&self) -> RawPublicKey { - RawPublicKey::from_uncompressed_bytes(&self.bytes).expect("PublicKey in invalid state") + pub fn as_raw(&self) -> &RawPublicKey { + &self.0 } /// Converts compressed bytes to PublicKey pub fn from_bytes(bytes: &[u8]) -> Result { - let mut pubkey = RawPublicKey::from_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; - Ok(Self { - bytes: pubkey.as_uncompressed_bytes(), - }) + let pubkey = RawPublicKey::from_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; + Ok(PublicKey(pubkey)) } /// Returns the PublicKey as (x, y) bytes pub fn as_uncompressed_bytes(&self) -> Vec { - self.bytes.clone() + RawPublicKey::as_uncompressed_bytes(&mut self.0.clone()) } /// Converts (x, y) bytes to PublicKey pub fn from_uncompressed_bytes(bytes: &[u8]) -> Result { - // Do a conversion to check the bytes are valid. - let _pubkey = + let pubkey = RawPublicKey::from_uncompressed_bytes(&bytes).map_err(|_| DecodeError::Invalid)?; - - Ok(Self { - bytes: bytes.to_vec(), - }) + Ok(PublicKey(pubkey)) } /// Returns the last 6 bytes of the SSZ encoding of the public key, as a hex string. @@ -83,22 +64,15 @@ impl default::Default for PublicKey { impl Encodable for PublicKey { fn ssz_append(&self, s: &mut SszStream) { - s.append_vec(&self.as_raw().as_bytes()); + s.append_vec(&self.0.as_bytes()); } } impl Decodable for PublicKey { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (sig_bytes, i) = decode_ssz_list(bytes, i)?; - let mut raw_sig = - RawPublicKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?; - - Ok(( - Self { - bytes: raw_sig.as_uncompressed_bytes(), - }, - i, - )) + let raw_sig = RawPublicKey::from_bytes(&sig_bytes).map_err(|_| DecodeError::TooShort)?; + Ok((PublicKey(raw_sig), i)) } } @@ -125,7 +99,7 @@ impl<'de> Deserialize<'de> for PublicKey { impl TreeHash for PublicKey { fn hash_tree_root(&self) -> Vec { - hash(&self.as_raw().as_bytes()) + hash(&self.0.as_bytes()) } } @@ -143,7 +117,7 @@ impl Hash for PublicKey { /// /// Use `ssz::Encode` to obtain the bytes required for consensus hashing. fn hash(&self, state: &mut H) { - self.bytes.hash(state) + self.as_uncompressed_bytes().hash(state) } } diff --git a/eth2/utils/bls/src/signature.rs b/eth2/utils/bls/src/signature.rs index 47e1dad2e..47598bc66 100644 --- a/eth2/utils/bls/src/signature.rs +++ b/eth2/utils/bls/src/signature.rs @@ -33,7 +33,7 @@ impl Signature { /// Verify the Signature against a PublicKey. pub fn verify(&self, msg: &[u8], domain: u64, pk: &PublicKey) -> bool { - self.0.verify(msg, domain, &pk.as_raw()) + self.0.verify(msg, domain, pk.as_raw()) } /// Verify the Signature against a PublicKey, where the message has already been hashed. @@ -44,7 +44,7 @@ impl Signature { pk: &PublicKey, ) -> bool { self.0 - .verify_hashed(x_real_hashed, x_imaginary_hashed, &pk.as_raw()) + .verify_hashed(x_real_hashed, x_imaginary_hashed, pk.as_raw()) } /// Returns the underlying signature. From 3dfdfc95ac84aac141ee24ddc89c8f35b53c87e7 Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Thu, 14 Mar 2019 17:53:13 +1100 Subject: [PATCH 5/5] Fix test_utils macro definition It needed to be defined before it was used in an module. --- eth2/types/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs index 4d13fd16c..7b1d84837 100644 --- a/eth2/types/src/lib.rs +++ b/eth2/types/src/lib.rs @@ -2,6 +2,7 @@ #[macro_use] pub mod test_utils; + pub mod attestation; pub mod attestation_data; pub mod attestation_data_and_custody_bit; @@ -24,7 +25,6 @@ pub mod proposer_slashing; pub mod readers; pub mod shard_reassignment_record; pub mod slashable_attestation; -pub mod test_utils; pub mod transfer; pub mod voluntary_exit; #[macro_use]