chore: re-define errors within rust crate

Author: LVivona

mrkle/src/builder.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 use crate::{
     DefaultIx, GenericArray, Hasher, IndexType, MrkleHasher, MrkleNode, MrkleTree, Node, NodeError,
-    NodeIndex, Tree, TreeError, prelude::*,
+    NodeIndex, Tree, TreeError, error::MrkleError, prelude::*,
 };
 
 /// A builder for constructing Merkle trees with default configuration.
@@ -290,21 +290,21 @@ impl<T, D: Digest, Ix: IndexType> MrkleDefaultBuilder<T, D, Ix> {
     pub fn insert_internal(
         &mut self,
         children: Vec<NodeIndex<Ix>>,
-    ) -> Result<NodeIndex<Ix>, TreeError> {
+    ) -> Result<NodeIndex<Ix>, MrkleError> {
         self.check_not_finalized()?;
 
         if children.is_empty() {
-            return Err(TreeError::InvalidOperation {
+            return Err(MrkleError::from(TreeError::InvalidOperation {
                 operation: "insert_internal",
                 reason: "internal nodes must have at least one child".to_string(),
-            });
+            }));
         }
 
         self.validate_children(&children)?;
 
-        let hash = self.compute_internal_hash(&children)?;
-
-        let index = self.tree.push(MrkleNode::internal(children.clone(), hash));
+        let index = self
+            .tree
+            .push(MrkleNode::internal(&self.tree, children.clone())?);
 
         self.set_parent_relationships(&children, index);
 
@@ -345,7 +345,7 @@ impl<T, D: Digest, Ix: IndexType> MrkleDefaultBuilder<T, D, Ix> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn finish(mut self, root: NodeIndex<Ix>) -> Result<MrkleTree<T, D, Ix>, TreeError> {
+    pub fn finish(mut self, root: NodeIndex<Ix>) -> Result<MrkleTree<T, D, Ix>, MrkleError> {
         self.check_not_finalized()?;
 
         // Validate the root node
@@ -356,11 +356,11 @@ impl<T, D: Digest, Ix: IndexType> MrkleDefaultBuilder<T, D, Ix> {
 
         // Perform comprehensive tree validation
         if let Err(errors) = self.validate() {
-            return Err(TreeError::ValidationFailed {
+            return Err(MrkleError::from(TreeError::ValidationFailed {
                 count: errors.len(),
                 summary: "Tree structure validation failed".to_string(),
                 errors,
-            });
+            }));
         }
 
         self.finalized = true;
@@ -508,10 +508,10 @@ impl<T, D: Digest, Ix: IndexType> MrkleDefaultBuilder<T, D, Ix> {
                     len: self.tree.len(),
                 })?;
             if node.parent().is_some() {
-                return Err(TreeError::ParentConflict {
+                return Err(TreeError::from(NodeError::ParentConflict {
                     parent: node.parent().unwrap().index(),
                     child: child.index(),
-                });
+                }));
             }
         }
         Ok(())
@@ -684,14 +684,14 @@ where
     pub fn build_complete_tree_from_leaves(
         &mut self,
         mut leaves: Vec<NodeIndex<Ix>>,
-    ) -> Result<NodeIndex<Ix>, TreeError> {
+    ) -> Result<NodeIndex<Ix>, MrkleError> {
         self.check_not_finalized()?;
 
         if leaves.is_empty() {
-            return Err(TreeError::InvalidOperation {
+            return Err(MrkleError::from(TreeError::InvalidOperation {
                 operation: "build_complete_tree_from_leaves",
                 reason: "cannot build tree from empty leaves vector".to_string(),
-            });
+            }));
         }
 
         // Base case: if there is only one node, create a root for single node.
@@ -743,7 +743,7 @@ where
     /// # Ok(())
     /// # }
     /// ```
-    pub fn build_from_data<I>(data_iter: I) -> Result<MrkleTree<T, D, Ix>, TreeError>
+    pub fn build_from_data<I>(data_iter: I) -> Result<MrkleTree<T, D, Ix>, MrkleError>
     where
         T: Clone,
         I: IntoIterator<Item = T>,
@@ -820,7 +820,7 @@ impl<T: AsRef<[u8]>, D: Digest, Ix: IndexType> MrkleDefaultBuilder<T, D, Ix> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn build_and_finish(mut self) -> Result<MrkleTree<T, D, Ix>, TreeError>
+    pub fn build_and_finish(mut self) -> Result<MrkleTree<T, D, Ix>, MrkleError>
     where
         T: Clone,
     {
@@ -947,12 +947,12 @@ mod tests {
 
         // Test empty children vector
         let result = builder.insert_internal(vec![]);
-        assert!(matches!(result, Err(TreeError::InvalidOperation { .. })));
+        assert!(result.is_err());
 
         // Test invalid child index
         let invalid_child = NodeIndex::new(999);
         let result = builder.insert_internal(vec![invalid_child]);
-        assert!(matches!(result, Err(TreeError::IndexOutOfBounds { .. })));
+        assert!(result.is_err());
 
         Ok(())
     }
@@ -968,7 +968,7 @@ mod tests {
 
         // Try to create second internal node with same children (should fail)
         let result = builder.insert_internal(vec![leaf1]);
-        assert!(matches!(result, Err(TreeError::ParentConflict { .. })));
+        assert!(result.is_err());
 
         Ok(())
     }

mrkle/src/error.rs

@@ -10,6 +10,27 @@ pub enum NodeError {
         /// The duplicate child index.
         child: usize,
     },
+
+    /// Attempted to assign a parent to a node that already has one.
+    ///
+    /// Each non-root node must have a single unique parent.
+    #[error(
+        "Cannot add child {child} to {parent}: \
+         node already has a parent."
+    )]
+    ParentConflict {
+        /// The node that is already the parent.
+        parent: usize,
+        /// The child node in conflict.
+        child: usize,
+    },
+
+    /// An index was used that is outside the bounds of the tree.
+    #[error("Node at {index:?} could not be found with in tree.")]
+    NodeNotFound {
+        /// node index within tree.
+        index: usize,
+    },
 }
 
 /// Errors that may occur when converting a byte slice into an [`entry`](crate::entry).
@@ -42,20 +63,6 @@ pub enum TreeError {
         len: usize,
     },
 
-    /// Attempted to assign a parent to a node that already has one.
-    ///
-    /// Each non-root node must have a single unique parent.
-    #[error(
-        "Cannot add child {child} to {parent}: \
-         node already has a parent."
-    )]
-    ParentConflict {
-        /// The node that is already the parent.
-        parent: usize,
-        /// The child node in conflict.
-        child: usize,
-    },
-
     /// An error occurred while operating on a [`Node`](crate::tree::Node).
     #[error("{0}")]
     NodeError(#[from] NodeError),

mrkle/src/lib.rs

@@ -32,6 +32,7 @@ pub mod tree;
 /// Includes errors for tree construction, hashing, and I/O operations.
 pub mod error;
 
+use crate::error::MrkleError;
 pub(crate) use crate::error::{EntryError, NodeError, ProofError, TreeError};
 pub(crate) use crate::tree::DefaultIx;
 
@@ -279,7 +280,7 @@ where
 }
 
 impl<T, D: Digest, Ix: IndexType> MrkleNode<T, D, Ix> {
-    /// Creates a new internal (non-leaf) node with the specified children and hash.
+    /// Creates a new internal (non-leaf) node with the specified children and tree.
     ///
     /// Internal nodes represent the structural components of the Merkle tree that
     /// combine child node hashes. They do not store application data directly
@@ -325,7 +326,44 @@ impl<T, D: Digest, Ix: IndexType> MrkleNode<T, D, Ix> {
     ///
     /// This method is `pub(crate)` as internal node creation should typically be
     /// managed by the tree construction algorithms rather than external users.
-    pub fn internal(children: Vec<NodeIndex<Ix>>, hash: GenericArray<D>) -> Self {
+    #[inline]
+    pub fn internal(
+        tree: &Tree<MrkleNode<T, D, Ix>, Ix>,
+        children: Vec<NodeIndex<Ix>>,
+    ) -> Result<Self, MrkleError> {
+        let mut hasher = D::new();
+        children
+            .iter()
+            .try_for_each(|&idx| {
+                if let Some(node) = tree.get(idx.index()) {
+                    if node.parent().is_some() {
+                        return Err(TreeError::from(NodeError::ParentConflict {
+                            parent: node.parent().unwrap().index(),
+                            child: idx.index(),
+                        }));
+                    }
+                    hasher.update(&node.hash());
+                    Ok(())
+                } else {
+                    Err(TreeError::from(NodeError::NodeNotFound {
+                        index: idx.index(),
+                    }))
+                }
+            })
+            .map_err(|e| MrkleError::from(e))?;
+
+        let hash = hasher.finalize();
+
+        Ok(Self {
+            payload: Payload::Internal,
+            parent: None,
+            children,
+            hash,
+        })
+    }
+
+    /// Creates a new internal (non-leaf) node with the specified children and tree.
+    pub fn internal_with_hash(hash: GenericArray<D>, children: Vec<NodeIndex<Ix>>) -> Self {
         Self {
             payload: Payload::Internal,
             parent: None,
@@ -823,7 +861,7 @@ where
     ///
     /// let tree = MrkleTree::<&str, Sha1>::from_leaves(leaves);
     /// ```
-    pub fn from_leaves(leaves: Vec<T>) -> Result<MrkleTree<T, D, Ix>, TreeError> {
+    pub fn from_leaves(leaves: Vec<T>) -> Result<MrkleTree<T, D, Ix>, MrkleError> {
         MrkleDefaultBuilder::build_from_data(leaves)
 
         // let mut tree = Tree::new();
@@ -1088,25 +1126,65 @@ where
 }
 
 #[cfg(feature = "serde")]
-impl<'de, T, D: Digest, Ix: IndexType> serde::Deserialize<'de> for MrkleTree<T, D, Ix>
+impl<'de, T, D, Ix> serde::Deserialize<'de> for MrkleTree<T, D, Ix>
 where
-    T: serde::Deserialize<'de>,
-    Ix: serde::Deserialize<'de>,
+    T: AsRef<[u8]> + serde::Deserialize<'de>,
+    D: Digest + Default,
+    Ix: IndexType + serde::Deserialize<'de>,
 {
-    fn deserialize<_D>(deserializer: _D) -> Result<Self, _D::Error>
+    fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>
     where
-        _D: serde::Deserializer<'de>,
+        De: serde::Deserializer<'de>,
     {
-        Ok(MrkleTree {
-            core: Tree::<MrkleNode<T, D, Ix>, Ix>::deserialize(deserializer)?,
-        })
+        // First, deserialize the underlying core tree structure
+        let core = Tree::<MrkleNode<T, D, Ix>, Ix>::deserialize(deserializer)?;
+
+        // Verify all nodes (leaf and internal) match their expected hashes
+        for node in core.iter() {
+            let mut digest = D::new();
+
+            if node.is_leaf() {
+                let value = node.value().ok_or_else(|| {
+                    serde::de::Error::custom("Leaf node missing value during deserialization")
+                })?;
+
+                digest.update(value.as_ref());
+                let computed = digest.finalize();
+
+                if computed.as_slice() != node.hash().as_slice() {
+                    return Err(serde::de::Error::custom("Merkle tree leaf hash mismatch"));
+                }
+            } else {
+                if node.child_count() == 0 {
+                    return Err(serde::de::Error::custom(
+                        "Internal node should never have no children.",
+                    ));
+                }
+
+                for child in node.children() {
+                    let child_node = core.get(child.index()).ok_or_else(|| {
+                        serde::de::Error::custom("Missing child node during deserialization")
+                    })?;
+                    digest.update(child_node.hash());
+                }
+
+                let computed = digest.finalize();
+                if &computed != node.hash() {
+                    return Err(serde::de::Error::custom(
+                        "Merkle tree internal hash mismatch",
+                    ));
+                }
+            }
+        }
+
+        Ok(MrkleTree { core })
     }
 }
 
 #[cfg(test)]
 mod test {
 
-    use crate::{Hasher, MrkleHasher, MrkleNode, MrkleTree, Node, NodeIndex, prelude::*};
+    use crate::{MrkleHasher, MrkleNode, MrkleTree, Node, NodeIndex, prelude::*};
     use sha1::Digest;
 
     const DATA_PAYLOAD: [u8; 32] = [0u8; 32];
@@ -1118,16 +1196,6 @@ mod test {
         assert!(tree.is_empty())
     }
 
-    #[test]
-    fn test_is_leaf_logic() {
-        let leaf = MrkleNode::<_, sha1::Sha1>::leaf(DATA_PAYLOAD);
-        assert!(leaf.is_leaf());
-
-        let hash = MrkleHasher::<sha1::Sha1>::digest(leaf.hash);
-        let internal = MrkleNode::<[u8; 32], sha1::Sha1>::internal(vec![NodeIndex::new(1)], hash);
-        assert!(!internal.is_leaf())
-    }
-
     #[test]
     fn test_default_mrkle_node() {
         let node = MrkleNode::<_, sha1::Sha1, usize>::leaf(DATA_PAYLOAD);
@@ -1143,46 +1211,6 @@ mod test {
         assert_eq!(node.hash, sha1::Sha1::digest(DATA_PAYLOAD))
     }
 
-    #[test]
-    fn test_build_internal_mrkle_node() {
-        let hasher = MrkleHasher::<sha1::Sha1>::new();
-        let node1 = MrkleNode::<_, sha1::Sha1, usize>::leaf_with_hasher(DATA_PAYLOAD, &hasher);
-        let node2 = MrkleNode::<_, sha1::Sha1, usize>::leaf_with_hasher(DATA_PAYLOAD, &hasher);
-
-        let children: Vec<NodeIndex<usize>> = vec![NodeIndex::new(0), NodeIndex::new(1)];
-
-        let hash = hasher.concat_slice(&[node1.hash, node2.hash]);
-
-        let parent: MrkleNode<[u8; 32], sha1::Sha1, usize> = MrkleNode::internal(children, hash);
-
-        // The expected hash should be just concat the two child
-        // using the same digest.
-        let expected = {
-            let mut hasher = sha1::Sha1::new();
-            hasher.update(node1.hash);
-            hasher.update(node2.hash);
-            hasher.finalize()
-        };
-
-        assert_eq!(parent.hash, expected);
-    }
-
-    #[test]
-    fn test_internal_contains_node_index() {
-        let hasher = MrkleHasher::<sha1::Sha1>::new();
-
-        let node1 = MrkleNode::<_, sha1::Sha1, usize>::leaf_with_hasher(DATA_PAYLOAD, &hasher);
-        let node2 = MrkleNode::<_, sha1::Sha1, usize>::leaf_with_hasher(DATA_PAYLOAD, &hasher);
-
-        let children: Vec<NodeIndex<usize>> = vec![NodeIndex::new(0), NodeIndex::new(1)];
-
-        let hash = hasher.concat_slice(&[node1.hash, node2.hash]);
-
-        let parent: MrkleNode<[u8; 32], sha1::Sha1, usize> = MrkleNode::internal(children, hash);
-
-        assert!(parent.contains(&NodeIndex::new(0)));
-    }
-
     #[test]
     fn test_building_binary_tree_base_case() {
         let leaves: Vec<&str> = vec!["A"];