1 files changed, 0 insertions, 96 deletions
diff --git a/src/merkle/node.rs b/src/merkle/node.rs
deleted file mode 100644
index cef5c1f..0000000
--- a/src/merkle/node.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-//! Contains node definitions for Merkle trees, including leaf and internal node structures.
-
-use crate::hasher::Hasher;
-
-/// Enum representing the type of a Merkle tree node.
-#[derive(Debug, Clone)]
-pub enum NodeType {
-    /// A leaf node that contains no children.
-    Leaf,
-    /// An internal node that has two children.
-    Internal(Box<Node>, Box<Node>),
-}
-
-impl NodeType {
-    /// Returns a reference to the left child if the node is internal.
-    pub fn left(&self) -> Option<&Node> {
-        match self {
-            NodeType::Leaf => None,
-            NodeType::Internal(l, _) => Some(l),
-        }
-    }
-
-    /// Returns a reference to the right child if the node is internal.
-    pub fn right(&self) -> Option<&Node> {
-        match self {
-            NodeType::Leaf => None,
-            NodeType::Internal(_, r) => Some(r),
-        }
-    }
-}
-
-/// Represents a node in a Merkle tree, either leaf or internal.
-#[derive(Debug, Clone)]
-pub struct Node {
-    /// Hash value stored at the node.
-    hash: String,
-    /// Type of the node: leaf or internal.
-    kind: NodeType,
-    /// Data in bytes.
-    data: Vec<u8>,
-}
-
-impl Node {
-    /// Constructs a new leaf node from input data.
-    ///
-    /// # Arguments
-    ///
-    /// * `hasher` - A reference to a hashing strategy.
-    /// * `data` - The data to be hashed and stored as a leaf.
-    pub fn new_leaf(hasher: &dyn Hasher, data: &[u8]) -> Self {
-        let hash = hasher.hash(data);
-        Self {
-            hash,
-            data: data.to_vec(),
-            kind: NodeType::Leaf,
-        }
-    }
-
-    /// Constructs a new internal node from two child nodes.
-    ///
-    /// # Arguments
-    ///
-    /// * `hasher` - A reference to a hashing strategy.
-    /// * `left` - Left child node.
-    /// * `right` - Right child node.
-    ///
-    /// # Behavior
-    ///
-    /// The internal node hash is computed as the hash of the concatenated children's hashes.
-    pub fn new_internal(hasher: &dyn Hasher, left: Node, right: Node) -> Self {
-        let mut buffer = Vec::<u8>::new();
-        buffer.extend_from_slice(left.hash().as_bytes());
-        buffer.extend_from_slice(right.hash().as_bytes());
-        let hash = hasher.hash(&buffer);
-        Self {
-            hash,
-            data: buffer,
-            kind: NodeType::Internal(Box::new(left), Box::new(right)),
-        }
-    }
-
-    /// Returns a reference to the hash of the node.
-    pub fn hash(&self) -> &str {
-        &self.hash
-    }
-
-    /// Returns the data value in bytes format.
-    pub fn data(&self) -> &[u8] {
-        &self.data
-    }
-
-    /// Returns a reference to the node's type (leaf or internal).
-    pub fn kind(&self) -> &NodeType {
-        &self.kind
-    }
-}