ProgressiveMerkleHasher and progressive container support

Cargo.toml

@@ -13,3 +13,6 @@ readme = "README.md"
 repository = "https://github.com/sigp/tree_hash"
 keywords = ["ethereum"]
 categories = ["cryptography::cryptocurrencies"]
+
+[patch.crates-io]
+ethereum_ssz = { path = "../ethereum_ssz/ssz" }

tree_hash/src/impls.rs

@@ -1,6 +1,6 @@
 use super::*;
 use alloy_primitives::{Address, FixedBytes, U128, U256};
-use ssz::{Bitfield, Fixed, Variable};
+use ssz::{Bitfield, Fixed, Progressive, Variable};
 use std::sync::Arc;
 use typenum::Unsigned;
 
@@ -208,6 +208,42 @@ impl<N: Unsigned + Clone> TreeHash for Bitfield<Variable<N>> {
     }
 }
 
+impl TreeHash for Bitfield<Progressive> {
+    fn tree_hash_type() -> TreeHashType {
+        TreeHashType::List
+    }
+
+    fn tree_hash_packed_encoding(&self) -> PackedEncoding {
+        unreachable!("ProgressiveBitField should never be packed.")
+    }
+
+    fn tree_hash_packing_factor() -> usize {
+        unreachable!("ProgressiveBitField should never be packed.")
+    }
+
+    fn tree_hash_root(&self) -> Hash256 {
+        // XXX: This is a workaround for the fact that the internal representation of bitfields is
+        // misaligned with the spec.
+        //
+        // See:
+        //
+        // - https://github.com/sigp/ethereum_ssz/pull/68
+        if self.is_empty() {
+            return mix_in_length(&Hash256::ZERO, 0);
+        }
+
+        let mut hasher = ProgressiveMerkleHasher::new();
+        hasher
+            .write(self.as_slice())
+            .expect("ProgessiveBitList should not exceed tree hash leaf limit");
+
+        let bitfield_root = hasher
+            .finish()
+            .expect("ProgressiveBitList tree hash buffer should not exceed leaf limit");
+        mix_in_length(&bitfield_root, self.len())
+    }
+}
+
 impl<N: Unsigned + Clone> TreeHash for Bitfield<Fixed<N>> {
     fn tree_hash_type() -> TreeHashType {
         TreeHashType::Vector

tree_hash/src/lib.rs

@@ -2,10 +2,14 @@ pub mod impls;
 mod merkle_hasher;
 mod merkleize_padded;
 mod merkleize_standard;
+mod progressive_merkle_hasher;
 
 pub use merkle_hasher::{Error, MerkleHasher};
 pub use merkleize_padded::merkleize_padded;
 pub use merkleize_standard::merkleize_standard;
+pub use progressive_merkle_hasher::{
+    Error as ProgressiveMerkleHasherError, ProgressiveMerkleHasher,
+};
 
 use ethereum_hashing::{hash_fixed, ZERO_HASHES, ZERO_HASHES_MAX_INDEX};
 use smallvec::SmallVec;
@@ -89,6 +93,13 @@ pub fn mix_in_selector(root: &Hash256, selector: u8) -> Option<Hash256> {
     Some(Hash256::from_slice(&root))
 }
 
+pub fn mix_in_active_fields(root: Hash256, active_fields: [u8; BYTES_PER_CHUNK]) -> Hash256 {
+    Hash256::from(ethereum_hashing::hash32_concat(
+        root.as_slice(),
+        &active_fields,
+    ))
+}
+
 /// Returns a cached padding node for a given height.
 fn get_zero_hash(height: usize) -> &'static [u8] {
     if height <= ZERO_HASHES_MAX_INDEX {