Support tree hash by value

Cargo.toml

@@ -25,3 +25,7 @@ itertools = "0.13.0"
 [dev-dependencies]
 serde_json = "1.0.0"
 tree_hash_derive = "0.8.0"
+
+[patch.crates-io]
+tree_hash = { git = "https://github.com/sigp/tree_hash", branch = "self-by-value" }
+tree_hash_derive = { git = "https://github.com/sigp/tree_hash", branch = "self-by-value" }

src/bitfield.rs

@@ -643,41 +643,41 @@ impl<'de, N: Unsigned + Clone> Deserialize<'de> for Bitfield<Fixed<N>> {
     }
 }
 
-impl<N: Unsigned + Clone> tree_hash::TreeHash for Bitfield<Variable<N>> {
+impl<N: Unsigned + Clone> tree_hash::TreeHash for &Bitfield<Variable<N>> {
     fn tree_hash_type() -> tree_hash::TreeHashType {
         tree_hash::TreeHashType::List
     }
 
-    fn tree_hash_packed_encoding(&self) -> tree_hash::PackedEncoding {
+    fn tree_hash_packed_encoding(self) -> tree_hash::PackedEncoding {
         unreachable!("List should never be packed.")
     }
 
     fn tree_hash_packing_factor() -> usize {
         unreachable!("List should never be packed.")
     }
 
-    fn tree_hash_root(&self) -> Hash256 {
+    fn tree_hash_root(self) -> Hash256 {
         // Note: we use `as_slice` because it does _not_ have the length-delimiting bit set (or
         // present).
         let root = bitfield_bytes_tree_hash_root::<N>(self.as_slice());
         tree_hash::mix_in_length(&root, self.len())
     }
 }
 
-impl<N: Unsigned + Clone> tree_hash::TreeHash for Bitfield<Fixed<N>> {
+impl<N: Unsigned + Clone> tree_hash::TreeHash for &Bitfield<Fixed<N>> {
     fn tree_hash_type() -> tree_hash::TreeHashType {
         tree_hash::TreeHashType::Vector
     }
 
-    fn tree_hash_packed_encoding(&self) -> tree_hash::PackedEncoding {
+    fn tree_hash_packed_encoding(self) -> tree_hash::PackedEncoding {
         unreachable!("Vector should never be packed.")
     }
 
     fn tree_hash_packing_factor() -> usize {
         unreachable!("Vector should never be packed.")
     }
 
-    fn tree_hash_root(&self) -> Hash256 {
+    fn tree_hash_root(self) -> Hash256 {
         bitfield_bytes_tree_hash_root::<N>(self.as_slice())
     }
 }

src/fixed_vector.rs

@@ -177,23 +177,23 @@ impl<T, N: Unsigned> IntoIterator for FixedVector<T, N> {
     }
 }
 
-impl<T, N: Unsigned> tree_hash::TreeHash for FixedVector<T, N>
+impl<'a, T, N: Unsigned> tree_hash::TreeHash for &'a FixedVector<T, N>
 where
-    T: tree_hash::TreeHash,
+    &'a T: tree_hash::TreeHash,
 {
     fn tree_hash_type() -> tree_hash::TreeHashType {
         tree_hash::TreeHashType::Vector
     }
 
-    fn tree_hash_packed_encoding(&self) -> tree_hash::PackedEncoding {
+    fn tree_hash_packed_encoding(self) -> tree_hash::PackedEncoding {
         unreachable!("Vector should never be packed.")
     }
 
     fn tree_hash_packing_factor() -> usize {
         unreachable!("Vector should never be packed.")
     }
 
-    fn tree_hash_root(&self) -> Hash256 {
+    fn tree_hash_root(self) -> Hash256 {
         vec_tree_hash_root::<T, N>(&self.vec)
     }
 }

src/tree_hash.rs

@@ -3,15 +3,16 @@ use typenum::Unsigned;
 
 /// A helper function providing common functionality between the `TreeHash` implementations for
 /// `FixedVector` and `VariableList`.
-pub fn vec_tree_hash_root<T, N>(vec: &[T]) -> Hash256
+pub fn vec_tree_hash_root<'a, T: 'a, N>(vec: &'a [T]) -> Hash256
 where
-    T: TreeHash,
+    &'a T: TreeHash,
     N: Unsigned,
 {
-    match T::tree_hash_type() {
+    match <&T>::tree_hash_type() {
         TreeHashType::Basic => {
             let mut hasher = MerkleHasher::with_leaves(
-                (N::to_usize() + T::tree_hash_packing_factor() - 1) / T::tree_hash_packing_factor(),
+                (N::to_usize() + <&T>::tree_hash_packing_factor() - 1)
+                    / <&T>::tree_hash_packing_factor(),
             );
 
             for item in vec {

src/variable_list.rs

@@ -193,23 +193,23 @@ impl<T, N: Unsigned> IntoIterator for VariableList<T, N> {
     }
 }
 
-impl<T, N: Unsigned> tree_hash::TreeHash for VariableList<T, N>
+impl<'a, T, N: Unsigned> tree_hash::TreeHash for &'a VariableList<T, N>
 where
-    T: tree_hash::TreeHash,
+    &'a T: tree_hash::TreeHash,
 {
     fn tree_hash_type() -> tree_hash::TreeHashType {
         tree_hash::TreeHashType::List
     }
 
-    fn tree_hash_packed_encoding(&self) -> tree_hash::PackedEncoding {
+    fn tree_hash_packed_encoding(self) -> tree_hash::PackedEncoding {
         unreachable!("List should never be packed.")
     }
 
     fn tree_hash_packing_factor() -> usize {
         unreachable!("List should never be packed.")
     }
 
-    fn tree_hash_root(&self) -> Hash256 {
+    fn tree_hash_root(self) -> Hash256 {
         let root = vec_tree_hash_root::<T, N>(&self.vec);
 
         tree_hash::mix_in_length(&root, self.len())