refactor(all): remove blake3 references

Removed all blake3 references from the codebase
other than the octez_riscv_data::hash module.

Author: danielpapp-trilitech

Cargo.lock

@@ -155,7 +155,7 @@ impl<T: Default + 'static, M: AtomMode> Default for Atom<T, M> {
 
 impl<T: Encode + 'static> Foldable<HashFold> for Atom<T, Normal> {
     fn fold(&self, _builder: HashFold) -> Hash {
-        Hash::blake3_hash(&self.atom).expect("Hashing should not fail")
+        Hash::hash_encodable(&self.atom).expect("Hashing should not fail")
     }
 }
 
@@ -166,7 +166,7 @@ impl<'normal, T: Encode + 'static> Foldable<HashFold> for Atom<T, Prove<'normal>
             .current
             .as_deref()
             .unwrap_or_else(|| &self.atom.previous);
-        Hash::blake3_hash(value).expect("Hashing should not fail")
+        Hash::hash_encodable(value).expect("Hashing should not fail")
     }
 }
 
@@ -187,7 +187,9 @@ impl<T: Encode + 'static> Foldable<PartialHashFold<'_>> for Atom<T, Verify> {
         let hash = match &self.atom {
             Partial::Absent => return builder.previous(),
             Partial::Blinded(hash) => *hash,
-            Partial::Present(value) => Hash::blake3_hash(value).expect("Hashing should not fail"),
+            Partial::Present(value) => {
+                Hash::hash_encodable(value).expect("Hashing should not fail")
+            }
         };
         PartialHash::Present(hash)
     }

data/src/components/atom.rs

@@ -7,6 +7,7 @@
 
 use std::borrow::Borrow;
 use std::collections::VecDeque;
+use std::ops::Deref;
 
 use bincode::Decode;
 use bincode::Encode;
@@ -35,38 +36,26 @@ pub enum HashError {
 }
 
 /// Size of digest produced by the underlying hash function
-pub const DIGEST_SIZE: usize = 32;
+const DIGEST_SIZE: usize = 32;
 
 /// A value of type [struct@Hash] indicates that the enclosed array is a digest
 /// produced by a preset hash function, currently BLAKE2b. It can be obtained
 /// by either hashing data directly or after hashing by converting from
 /// a suitably sized byte slice or vector.
-#[derive(
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    Encode,
-    Decode,
-    Hash,
-    PartialOrd,
-    Ord,
-    derive_more::From,
-    derive_more::Debug,
-)]
+#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, Hash, PartialOrd, Ord, derive_more::Debug)]
 #[debug("{}", self)]
 pub struct Hash {
     digest: [u8; DIGEST_SIZE],
 }
 
 impl Hash {
-    /// Hashes a byte slice into a [`Hash`] object.
+    /// Hashes a byte slice into a [`struct@Hash`].
     pub fn hash_bytes(bytes: &[u8]) -> Self {
         let digest = blake3::hash(bytes).into();
         Hash { digest }
     }
 
-    /// Creates a [`Hash`] object from something that implements the
+    /// Creates a [`struct@Hash`] from something that implements the
     /// [`bincode::enc::Encode`] trait.
     pub fn hash_encodable<T: Encode>(data: T) -> Result<Self, EncodeError> {
         let mut hasher = blake3::Hasher::new();
@@ -76,9 +65,9 @@ impl Hash {
         Ok(Hash { digest })
     }
 
-    /// Creates a [`Hash`] object from a collection of iterables
-    /// that can be [`Borrow`]ed as a [`Hash`]. Note that this
-    /// method  is rehashing the hashes!
+    /// Creates a [`struct@Hash`] from a collection of iterables that can be
+    /// [`Deref`]ed as a [`struct@Hash`]. Note that this method  is rehashing the
+    /// hashes!
     pub fn combine_hashes<H: Borrow<Hash>, HS: IntoIterator<Item = H>>(hashes: HS) -> Hash {
         let mut hasher = blake3::Hasher::new();
 
@@ -95,6 +84,11 @@ impl Hash {
     pub fn from_foldable(foldable: &impl Foldable<HashFold>) -> Self {
         foldable.fold(HashFold)
     }
+
+    /// The length of the hash digest
+    pub const fn digest_len() -> usize {
+        DIGEST_SIZE
+    }
 }
 
 impl std::fmt::Display for Hash {
@@ -103,6 +97,12 @@ impl std::fmt::Display for Hash {
     }
 }
 
+impl From<[u8; DIGEST_SIZE]> for Hash {
+    fn from(value: [u8; DIGEST_SIZE]) -> Self {
+        Self { digest: value }
+    }
+}
+
 impl From<Hash> for [u8; DIGEST_SIZE] {
     fn from(value: Hash) -> Self {
         value.digest
@@ -121,34 +121,42 @@ impl Foldable<HashFold> for Hash {
     }
 }
 
+impl Deref for Hash {
+    type Target = [u8; DIGEST_SIZE];
+
+    fn deref(&self) -> &Self::Target {
+        &self.digest
+    }
+}
+
+/// [struct@Hasher] can be dynamically updated with byte arrays and [`struct@Hash`]s and
+/// can be turned into a [`struct@Hash`].
+#[derive(Default)]
 pub struct Hasher {
     hasher: blake3::Hasher,
 }
 
 impl Hasher {
-    /// Creates a new [`Hasher`] object
-    pub fn new() -> Self {
-        Self {
-            hasher: blake3::Hasher::new(),
-        }
-    }
-
     /// Updates the [`Hasher`] with some bytes
     pub fn update_with_bytes(&mut self, bytes: &[u8]) {
         self.hasher.update(bytes);
     }
 
-    /// Updates the [`Hasher`] with the digest of a [`Hash`]
-    pub fn update_with_hash(&mut self, hash: Hash) {
-        let digest: [u8; DIGEST_SIZE] = hash.into();
-        self.hasher.update(digest.as_slice());
+    /// Updates the [`Hasher`] with the digest of a [`struct@Hash`]
+    pub fn update_with_hash(&mut self, hash: &Hash) {
+        self.hasher.update(hash.deref());
     }
 
-    /// Turns the [`Hasher`] into a [`Hash`]
+    /// Turns the [`Hasher`] into a [`struct@Hash`]
     pub fn to_hash(self) -> Hash {
         let digest: [u8; DIGEST_SIZE] = self.hasher.finalize().into();
         Hash { digest }
     }
+
+    /// Returns the number of bytes hashed so far.
+    pub fn count(&self) -> u64 {
+        self.hasher.count()
+    }
 }
 
 /// [`Fold`] implementation producing a [`struct@Hash`]
@@ -171,20 +179,19 @@ impl Fold for HashFold {
 #[derive(Default)]
 pub struct HashNodeFold {
     /// Hasher used to combine children's hashes
-    hasher: blake3::Hasher,
+    hasher: Hasher,
 }
 
 impl NodeFold for HashNodeFold {
     type Parent = HashFold;
 
     fn add<F: Foldable<HashFold>>(&mut self, child: &F) {
         let folded_child = child.fold(HashFold);
-        self.hasher.update(folded_child.as_ref());
+        self.hasher.update_with_bytes(folded_child.as_ref());
     }
 
     fn done(self) -> Hash {
-        let digest = self.hasher.finalize().into();
-        Hash { digest }
+        self.hasher.to_hash()
     }
 }
 
@@ -343,7 +350,7 @@ impl<'tree> NodeFold for PartialHashNodeFold<'tree> {
 
     fn done(self) -> PartialHash {
         let mut saw_absent_child = false;
-        let mut hasher = blake3::Hasher::new();
+        let mut hasher = Hasher::default();
 
         for child_hash in self.child_hashes {
             match child_hash {
@@ -365,7 +372,7 @@ impl<'tree> NodeFold for PartialHashNodeFold<'tree> {
                         return PartialHash::InvalidProof;
                     }
 
-                    hasher.update(hash.as_ref());
+                    hasher.update_with_hash(&hash);
                 }
 
                 PartialHash::InvalidProof => {
@@ -383,20 +390,19 @@ impl<'tree> NodeFold for PartialHashNodeFold<'tree> {
                 .unwrap_or(PartialHash::Previous);
         }
 
-        let digest: [u8; 32] = hasher.finalize().into();
-        let hash = Hash::from(digest);
-        PartialHash::Present(hash)
+        PartialHash::Present(hasher.to_hash())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::DIGEST_SIZE;
+    use std::borrow::Borrow;
+
+    use bincode::Encode;
+
     use super::Hash;
     use super::Hasher;
     use crate::serialisation::bincode_default_config;
-    use bincode::Encode;
-    use std::borrow::Borrow;
 
     #[derive(Clone, Encode)]
     struct Encodable {
@@ -430,20 +436,20 @@ mod tests {
     fn hash_bytes_works_as_blake3_hashing() {
         let bytes = [1, 2, 3];
         let hash = Hash::hash_bytes(&bytes);
-        let hash_digest: [u8; DIGEST_SIZE] = hash.into();
-        let blake3_digest: [u8; DIGEST_SIZE] = blake3::hash(&bytes).into();
+        let hash_digest: [u8; Hash::digest_len()] = hash.into();
+        let blake3_digest: [u8; 32] = blake3::hash(&bytes).into();
         assert_eq!(hash_digest, blake3_digest);
     }
 
     #[test]
-    fn hash_encodable_can_hash_encodable_objects() {
-        let object = Encodable::new(12);
-        let bytes =
-            bincode::encode_to_vec(object.clone(), bincode_default_config()).expect("Should work");
-        let object_hash_digest: [u8; DIGEST_SIZE] = blake3::hash(bytes.as_slice()).into();
-        let hash_digest: [u8; DIGEST_SIZE] =
-            Hash::hash_encodable(object).expect("Should work").into();
-        assert_eq!(object_hash_digest, hash_digest);
+    fn hash_encodable_can_hash_encodables() {
+        let encodable = Encodable::new(12);
+        let bytes = bincode::encode_to_vec(encodable.clone(), bincode_default_config())
+            .expect("Should work");
+        let encodable_hash_digest: blake3::Hash = blake3::hash(bytes.as_slice());
+        let hash_digest: [u8; Hash::digest_len()] =
+            Hash::hash_encodable(encodable).expect("Should work").into();
+        assert_eq!(encodable_hash_digest, hash_digest);
     }
 
     #[test]
@@ -453,14 +459,14 @@ mod tests {
             Borrowable::new(Hash::hash_bytes(&[4, 5, 6])),
         ];
         let hash = Hash::combine_hashes(coll.clone());
-        let hash_digest: [u8; DIGEST_SIZE] = hash.into();
+        let hash_digest: [u8; Hash::digest_len()] = hash.into();
 
         let mut hasher = blake3::Hasher::new();
         let mut borrowed_hash: &Hash = coll[0].borrow();
         hasher.update(borrowed_hash.as_ref());
         borrowed_hash = coll[1].borrow();
         hasher.update(borrowed_hash.as_ref());
-        let hasher_digest: [u8; DIGEST_SIZE] = hasher.finalize().into();
+        let hasher_digest: [u8; Hash::digest_len()] = hasher.finalize().into();
 
         assert_eq!(hash_digest, hasher_digest);
 
@@ -472,7 +478,7 @@ mod tests {
     #[test]
     fn hasher_update_with_bytes_is_the_same_as_hash_bytes() {
         let elems: Vec<Vec<u8>> = vec![vec![1, 2, 3], vec![4, 5, 6]];
-        let mut hasher: Hasher = Hasher::new();
+        let mut hasher: Hasher = Hasher::default();
 
         for elem in elems.iter() {
             hasher.update_with_bytes(elem.as_slice());
@@ -490,10 +496,10 @@ mod tests {
 
         let hash = Hash::combine_hashes(elems.clone());
 
-        let mut hasher = Hasher::new();
+        let mut hasher = Hasher::default();
 
         for elem in elems.into_iter() {
-            hasher.update_with_hash(elem);
+            hasher.update_with_hash(&elem);
         }
 
         assert_eq!(hash, hasher.to_hash());

data/src/hash.rs

@@ -8,7 +8,6 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
-blake3.workspace = true
 bincode.workspace = true
 bytes.workspace = true
 cfg-if.workspace = true
@@ -21,7 +20,6 @@ thiserror.workspace = true
 tokio.workspace = true
 
 [dev-dependencies]
-blake3.workspace = true
 proptest.workspace = true
 criterion.workspace = true
 rand.workspace = true

durable-storage/Cargo.toml

@@ -10,6 +10,7 @@
 use std::sync::Arc;
 
 use bytes::Bytes;
+use octez_riscv_data::hash::Hash;
 use tokio::runtime::Handle;
 
 use crate::merkle_layer::Key;
@@ -66,7 +67,7 @@ impl Database {
 
     /// Obtain, and possibly calculate, the root hash of the database>
     #[cfg_attr(not(test), expect(dead_code, reason = "Implemented in RV-827"))]
-    pub(crate) fn hash(&self) -> blake3::Hash {
+    pub(crate) fn hash(&self) -> Hash {
         self.merkle.hash()
     }