Publish ssz_types (and deps) to crates.io (#468)

* Rename `hashing` crate to `eth2_hashing`

* Add license, desc to eth2_hashing Cargo.toml

* Remove merkle root from eth2 hashing

* Remove old benches folder (zombied from old branch)

* Add docs to eth2_hashing

* Prepare tree_hash for publishing on crates.io

* Update deps to use crates.io instead of paths

* Update all crates to pull ssz from crates.io

* Remove cached_tree_hash, add patches to manifest

* Fix compile error in benches

* Remove unused code

* Fix fake_crypto compile error

eth2/types/src/attestation.rs

@@ -5,7 +5,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// Details an attestation that can be slashable.
 ///
@@ -19,7 +19,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -59,5 +58,5 @@ mod tests {
     use crate::*;
 
     ssz_tests!(Attestation<MainnetEthSpec>);
-    cached_tree_hash_tests!(Attestation<MainnetEthSpec>);
+
 }

eth2/types/src/attestation_data.rs

@@ -5,7 +5,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// The data upon which an attestation is based.
 ///
@@ -21,7 +21,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -42,5 +41,4 @@ mod tests {
     use super::*;
 
     ssz_tests!(AttestationData);
-    cached_tree_hash_tests!(AttestationData);
 }

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -3,23 +3,12 @@ use crate::test_utils::TestRandom;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Used for pairing an attestation with a proof-of-custody.
 ///
 /// Spec v0.8.1
-#[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct AttestationDataAndCustodyBit {
     pub data: AttestationData,
     pub custody_bit: bool,
@@ -30,5 +19,5 @@ mod test {
     use super::*;
 
     ssz_tests!(AttestationDataAndCustodyBit);
-    cached_tree_hash_tests!(AttestationDataAndCustodyBit);
+
 }

eth2/types/src/attester_slashing.rs

@@ -3,23 +3,12 @@ use crate::{test_utils::TestRandom, EthSpec, IndexedAttestation};
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Two conflicting attestations.
 ///
 /// Spec v0.8.0
-#[derive(
-    Debug,
-    PartialEq,
-    Clone,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 #[serde(bound = "T: EthSpec")]
 pub struct AttesterSlashing<T: EthSpec> {
     pub attestation_1: IndexedAttestation<T>,
@@ -32,5 +21,5 @@ mod tests {
     use crate::*;
 
     ssz_tests!(AttesterSlashing<MainnetEthSpec>);
-    cached_tree_hash_tests!(AttesterSlashing<MainnetEthSpec>);
+
 }

eth2/types/src/beacon_block.rs

@@ -6,7 +6,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::{SignedRoot, TreeHash};
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// A block of the `BeaconChain`.
 ///
@@ -20,7 +20,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -104,5 +103,4 @@ mod tests {
     use super::*;
 
     ssz_tests!(BeaconBlock<MainnetEthSpec>);
-    cached_tree_hash_tests!(BeaconBlock<MainnetEthSpec>);
 }

eth2/types/src/beacon_block_body.rs

@@ -6,23 +6,12 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use ssz_types::VariableList;
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// The body of a `BeaconChain` block, containing operations.
 ///
 /// Spec v0.8.0
-#[derive(
-    Debug,
-    PartialEq,
-    Clone,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 #[serde(bound = "T: EthSpec")]
 pub struct BeaconBlockBody<T: EthSpec> {
     pub randao_reveal: Signature,
@@ -42,5 +31,4 @@ mod tests {
     use super::*;
 
     ssz_tests!(BeaconBlockBody<MainnetEthSpec>);
-    cached_tree_hash_tests!(BeaconBlockBody<MainnetEthSpec>);
 }

eth2/types/src/beacon_block_header.rs

@@ -6,7 +6,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::{SignedRoot, TreeHash};
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// A header of a `BeaconBlock`.
 ///
@@ -20,7 +20,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -60,5 +59,4 @@ mod tests {
     use super::*;
 
     ssz_tests!(BeaconBlockHeader);
-    cached_tree_hash_tests!(BeaconBlockHeader);
 }

eth2/types/src/beacon_state.rs

@@ -2,9 +2,8 @@ use self::committee_cache::get_active_validator_indices;
 use self::exit_cache::ExitCache;
 use crate::test_utils::TestRandom;
 use crate::*;
-use cached_tree_hash::{Error as TreeHashCacheError, TreeHashCache};
 use compare_fields_derive::CompareFields;
-use hashing::hash;
+use eth2_hashing::hash;
 use int_to_bytes::{int_to_bytes32, int_to_bytes8};
 use pubkey_cache::PubkeyCache;
 use serde_derive::{Deserialize, Serialize};
@@ -13,7 +12,7 @@ use ssz_derive::{Decode, Encode};
 use ssz_types::{typenum::Unsigned, BitVector, FixedVector};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 pub use self::committee_cache::CommitteeCache;
 pub use beacon_state_types::*;
@@ -58,7 +57,6 @@ pub enum Error {
     CurrentCommitteeCacheUninitialized,
     RelativeEpochError(RelativeEpochError),
     CommitteeCacheUninitialized(RelativeEpoch),
-    TreeHashCacheError(TreeHashCacheError),
     SszTypesError(ssz_types::Error),
 }
 
@@ -76,7 +74,6 @@ pub enum Error {
     Decode,
     TreeHash,
     CompareFields,
-    CachedTreeHash,
 )]
 #[serde(bound = "T: EthSpec")]
 pub struct BeaconState<T>
@@ -151,12 +148,6 @@ where
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    pub tree_hash_cache: TreeHashCache,
-    #[serde(skip_serializing, skip_deserializing)]
-    #[ssz(skip_serializing)]
-    #[ssz(skip_deserializing)]
-    #[tree_hash(skip_hashing)]
-    #[test_random(default)]
     pub exit_cache: ExitCache,
 }
 
@@ -218,7 +209,6 @@ impl<T: EthSpec> BeaconState<T> {
                 CommitteeCache::default(),
             ],
             pubkey_cache: PubkeyCache::default(),
-            tree_hash_cache: TreeHashCache::default(),
             exit_cache: ExitCache::default(),
         }
     }
@@ -929,22 +919,12 @@ impl<T: EthSpec> BeaconState<T> {
     ///
     /// Returns the `tree_hash_root` resulting from the update. This root can be considered the
     /// canonical root of `self`.
+    ///
+    /// ## Note
+    ///
+    /// Cache not currently implemented, just performs a full tree hash.
     pub fn update_tree_hash_cache(&mut self) -> Result<Hash256, Error> {
-        /* TODO(#440): re-enable cached tree hash
-        if self.tree_hash_cache.is_empty() {
-            self.tree_hash_cache = TreeHashCache::new(self)?;
-        } else {
-            // Move the cache outside of `self` to satisfy the borrow checker.
-            let mut cache = std::mem::replace(&mut self.tree_hash_cache, TreeHashCache::default());
-
-            cache.update(self)?;
-
-            // Move the updated cache back into `self`.
-            self.tree_hash_cache = cache
-        }
-
-        self.cached_tree_hash_root()
-        */
+        // TODO(#440): re-enable cached tree hash
         Ok(Hash256::from_slice(&self.tree_hash_root()))
     }
 
@@ -954,19 +934,22 @@ impl<T: EthSpec> BeaconState<T> {
     ///
     /// Returns an error if the cache is not initialized or if an error is encountered during the
     /// cache update.
+    ///
+    /// ## Note
+    ///
+    /// Cache not currently implemented, just performs a full tree hash.
     pub fn cached_tree_hash_root(&self) -> Result<Hash256, Error> {
-        /* TODO(#440): re-enable cached tree hash
-        self.tree_hash_cache
-            .tree_hash_root()
-            .and_then(|b| Ok(Hash256::from_slice(b)))
-            .map_err(Into::into)
-        */
+        // TODO(#440): re-enable cached tree hash
         Ok(Hash256::from_slice(&self.tree_hash_root()))
     }
 
     /// Completely drops the tree hash cache, replacing it with a new, empty cache.
+    ///
+    /// ## Note
+    ///
+    /// Cache not currently implemented, is a no-op.
     pub fn drop_tree_hash_cache(&mut self) {
-        self.tree_hash_cache = TreeHashCache::default()
+        // TODO(#440): re-enable cached tree hash
     }
 }
 
@@ -976,12 +959,6 @@ impl From<RelativeEpochError> for Error {
     }
 }
 
-impl From<TreeHashCacheError> for Error {
-    fn from(e: TreeHashCacheError) -> Error {
-        Error::TreeHashCacheError(e)
-    }
-}
-
 impl From<ssz_types::Error> for Error {
     fn from(e: ssz_types::Error) -> Error {
         Error::SszTypesError(e)

eth2/types/src/beacon_state/tests.rs

@@ -4,7 +4,6 @@ use crate::test_utils::*;
 use std::ops::RangeInclusive;
 
 ssz_tests!(FoundationBeaconState);
-cached_tree_hash_tests!(FoundationBeaconState);
 
 fn test_beacon_proposer_index<T: EthSpec>() {
     let spec = T::default_spec();

eth2/types/src/checkpoint.rs

@@ -4,7 +4,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// Casper FFG checkpoint, used in attestations.
 ///
@@ -21,7 +21,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -35,5 +34,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(Checkpoint);
-    cached_tree_hash_tests!(Checkpoint);
+
 }

eth2/types/src/compact_committee.rs

@@ -4,21 +4,10 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use ssz_types::VariableList;
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Spec v0.8.0
-#[derive(
-    Clone,
-    Debug,
-    PartialEq,
-    TreeHash,
-    CachedTreeHash,
-    Encode,
-    Decode,
-    Serialize,
-    Deserialize,
-    TestRandom,
-)]
+#[derive(Clone, Debug, PartialEq, TreeHash, Encode, Decode, Serialize, Deserialize, TestRandom)]
 #[serde(bound = "T: EthSpec")]
 pub struct CompactCommittee<T: EthSpec> {
     pub pubkeys: VariableList<PublicKey, T::MaxValidatorsPerCommittee>,

eth2/types/src/crosslink.rs

@@ -4,7 +4,7 @@ use crate::{Epoch, Hash256};
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Specifies the block hash for a shard at an epoch.
 ///
@@ -21,7 +21,6 @@ use tree_hash_derive::{CachedTreeHash, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
 )]
 pub struct Crosslink {
@@ -38,5 +37,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(Crosslink);
-    cached_tree_hash_tests!(Crosslink);
+
 }

eth2/types/src/crosslink_committee.rs

@@ -1,7 +1,7 @@
 use crate::*;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
-#[derive(Default, Clone, Debug, PartialEq, TreeHash, CachedTreeHash)]
+#[derive(Default, Clone, Debug, PartialEq, TreeHash)]
 pub struct CrosslinkCommittee<'a> {
     pub slot: Slot,
     pub shard: Shard,
@@ -18,7 +18,7 @@ impl<'a> CrosslinkCommittee<'a> {
     }
 }
 
-#[derive(Default, Clone, Debug, PartialEq, TreeHash, CachedTreeHash)]
+#[derive(Default, Clone, Debug, PartialEq, TreeHash)]
 pub struct OwnedCrosslinkCommittee {
     pub slot: Slot,
     pub shard: Shard,

eth2/types/src/deposit.rs

@@ -5,23 +5,12 @@ use ssz_types::typenum::U33;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// A deposit to potentially become a beacon chain validator.
 ///
 /// Spec v0.8.0
-#[derive(
-    Debug,
-    PartialEq,
-    Clone,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Deposit {
     pub proof: FixedVector<Hash256, U33>,
     pub data: DepositData,
@@ -32,5 +21,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(Deposit);
-    cached_tree_hash_tests!(Deposit);
+
 }

eth2/types/src/deposit_data.rs

@@ -7,7 +7,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::{SignedRoot, TreeHash};
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// The data supplied by the user to the deposit contract.
 ///
@@ -22,7 +22,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Decode,
     SignedRoot,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
 )]
 pub struct DepositData {
@@ -56,5 +55,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(DepositData);
-    cached_tree_hash_tests!(DepositData);
+
 }

eth2/types/src/eth1_data.rs

@@ -4,23 +4,13 @@ use crate::test_utils::TestRandom;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Contains data obtained from the Eth1 chain.
 ///
 /// Spec v0.8.1
 #[derive(
-    Debug,
-    PartialEq,
-    Clone,
-    Default,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
+    Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
 )]
 pub struct Eth1Data {
     pub deposit_root: Hash256,
@@ -33,5 +23,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(Eth1Data);
-    cached_tree_hash_tests!(Eth1Data);
+
 }

eth2/types/src/fork.rs

@@ -5,23 +5,13 @@ use crate::Epoch;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Specifies a fork of the `BeaconChain`, to prevent replay attacks.
 ///
 /// Spec v0.8.1
 #[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Default,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
+    Debug, Clone, PartialEq, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
 )]
 pub struct Fork {
     #[serde(
@@ -65,7 +55,6 @@ mod tests {
     use super::*;
 
     ssz_tests!(Fork);
-    cached_tree_hash_tests!(Fork);
 
     fn test_genesis(epoch: Epoch) {
         let fork = Fork::genesis(epoch);

eth2/types/src/historical_batch.rs

@@ -5,23 +5,12 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use ssz_types::FixedVector;
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Historical block and state roots.
 ///
 /// Spec v0.8.1
-#[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct HistoricalBatch<T: EthSpec> {
     pub block_roots: FixedVector<Hash256, T::SlotsPerHistoricalRoot>,
     pub state_roots: FixedVector<Hash256, T::SlotsPerHistoricalRoot>,
@@ -34,5 +23,5 @@ mod tests {
     pub type FoundationHistoricalBatch = HistoricalBatch<MainnetEthSpec>;
 
     ssz_tests!(FoundationHistoricalBatch);
-    cached_tree_hash_tests!(FoundationHistoricalBatch);
+
 }

eth2/types/src/indexed_attestation.rs

@@ -3,7 +3,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// Details an attestation that can be slashable.
 ///
@@ -19,7 +19,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -124,7 +123,6 @@ mod tests {
     }
 
     ssz_tests!(IndexedAttestation<MainnetEthSpec>);
-    cached_tree_hash_tests!(IndexedAttestation<MainnetEthSpec>);
 
     fn create_indexed_attestation(
         target_epoch: u64,

eth2/types/src/pending_attestation.rs

@@ -4,23 +4,12 @@ use crate::{AttestationData, BitList, EthSpec};
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// An attestation that has been included in the state but not yet fully processed.
 ///
 /// Spec v0.8.0
-#[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct PendingAttestation<T: EthSpec> {
     pub aggregation_bits: BitList<T::MaxValidatorsPerCommittee>,
     pub data: AttestationData,
@@ -34,5 +23,5 @@ mod tests {
     use crate::*;
 
     ssz_tests!(PendingAttestation<MainnetEthSpec>);
-    cached_tree_hash_tests!(PendingAttestation<MainnetEthSpec>);
+
 }

eth2/types/src/proposer_slashing.rs

@@ -4,23 +4,12 @@ use crate::test_utils::TestRandom;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Two conflicting proposals from the same proposer (validator).
 ///
 /// Spec v0.8.1
-#[derive(
-    Debug,
-    PartialEq,
-    Clone,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TreeHash,
-    CachedTreeHash,
-    TestRandom,
-)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
     pub header_1: BeaconBlockHeader,
@@ -32,5 +21,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(ProposerSlashing);
-    cached_tree_hash_tests!(ProposerSlashing);
+
 }

eth2/types/src/slot_epoch_macros.rs

@@ -238,26 +238,6 @@ macro_rules! impl_ssz {
             }
         }
 
-        impl cached_tree_hash::CachedTreeHash for $type {
-            fn new_tree_hash_cache(
-                &self,
-                depth: usize,
-            ) -> Result<cached_tree_hash::TreeHashCache, cached_tree_hash::Error> {
-                self.0.new_tree_hash_cache(depth)
-            }
-
-            fn tree_hash_cache_schema(&self, depth: usize) -> cached_tree_hash::BTreeSchema {
-                self.0.tree_hash_cache_schema(depth)
-            }
-
-            fn update_tree_hash_cache(
-                &self,
-                cache: &mut cached_tree_hash::TreeHashCache,
-            ) -> Result<(), cached_tree_hash::Error> {
-                self.0.update_tree_hash_cache(cache)
-            }
-        }
-
         impl TestRandom for $type {
             fn random_for_test(rng: &mut impl RngCore) -> Self {
                 $type::from(u64::random_for_test(rng))
@@ -579,7 +559,6 @@ macro_rules! all_tests {
         math_between_tests!($type, $type);
         math_tests!($type);
         ssz_tests!($type);
-        cached_tree_hash_tests!($type);
 
         mod u64_tests {
             use super::*;

eth2/types/src/test_utils/macros.rs

@@ -33,53 +33,3 @@ macro_rules! ssz_tests {
         }
     };
 }
-
-#[cfg(test)]
-#[macro_export]
-macro_rules! cached_tree_hash_tests {
-    ($type: ty) => {
-        #[test]
-        #[ignore]
-        // FIXME: re-enable https://github.com/sigp/lighthouse/issues/440
-        pub fn test_cached_tree_hash() {
-            use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-            use tree_hash::TreeHash;
-
-            let mut rng = XorShiftRng::from_seed([42; 16]);
-
-            // Test the original hash
-            let original = <$type>::random_for_test(&mut rng);
-            let mut cache = cached_tree_hash::TreeHashCache::new(&original).unwrap();
-
-            assert_eq!(
-                cache.tree_hash_root().unwrap().to_vec(),
-                original.tree_hash_root(),
-                "Original hash failed."
-            );
-
-            // Test the updated hash
-            let modified = <$type>::random_for_test(&mut rng);
-            cache.update(&modified).unwrap();
-            assert_eq!(
-                cache.tree_hash_root().unwrap().to_vec(),
-                modified.tree_hash_root(),
-                "Modification hash failed"
-            );
-
-            // Produce a new cache for the modified object and compare it to the updated cache.
-            let mut modified_cache = cached_tree_hash::TreeHashCache::new(&modified).unwrap();
-
-            // Reset the caches.
-            cache.reset_modifications();
-            modified_cache.reset_modifications();
-
-            // Ensure the modified cache is the same as a newly created cache. This is a sanity
-            // check to make sure there are no artifacts of the original cache remaining after an
-            // update.
-            assert_eq!(
-                modified_cache, cache,
-                "The modified cache does not match a new cache."
-            )
-        }
-    };
-}

eth2/types/src/transfer.rs

@@ -7,7 +7,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// The data submitted to the deposit contract.
 ///
@@ -20,7 +20,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
     Derivative,
@@ -43,5 +42,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(Transfer);
-    cached_tree_hash_tests!(Transfer);
+
 }

eth2/types/src/validator.rs

@@ -3,23 +3,12 @@ use crate::{test_utils::TestRandom, Epoch, Hash256, PublicKey};
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash_derive::{CachedTreeHash, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// Information about a `BeaconChain` validator.
 ///
 /// Spec v0.8.0
-#[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Encode,
-    Decode,
-    TestRandom,
-    TreeHash,
-    CachedTreeHash,
-)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TestRandom, TreeHash)]
 pub struct Validator {
     pub pubkey: PublicKey,
     pub withdrawal_credentials: Hash256,
@@ -128,5 +117,5 @@ mod tests {
     }
 
     ssz_tests!(Validator);
-    cached_tree_hash_tests!(Validator);
+
 }

eth2/types/src/voluntary_exit.rs

@@ -5,7 +5,7 @@ use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
 use tree_hash::TreeHash;
-use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
+use tree_hash_derive::{SignedRoot, TreeHash};
 
 /// An exit voluntarily submitted a validator who wishes to withdraw.
 ///
@@ -19,7 +19,6 @@ use tree_hash_derive::{CachedTreeHash, SignedRoot, TreeHash};
     Encode,
     Decode,
     TreeHash,
-    CachedTreeHash,
     TestRandom,
     SignedRoot,
 )]
@@ -36,5 +35,5 @@ mod tests {
     use super::*;
 
     ssz_tests!(VoluntaryExit);
-    cached_tree_hash_tests!(VoluntaryExit);
+
 }