3 files changed, 51 insertions, 41 deletions

diff --git a/src/hasher.rs b/src/hasher.rs
index 77a8450..d27a7e5 100644
--- a/src/hasher.rs
+++ b/src/hasher.rs
@@ -15,8 +15,9 @@ pub trait Hasher {
 pub struct DummyHasher;
 
 impl Hasher for DummyHasher {
-    fn hash(&self, _input: &[u8]) -> String {
-        "0xc0ff3".to_string()
+    fn hash(&self, input: &[u8]) -> String {
+        let sum: u32 = input.iter().map(|&b| b as u32).sum();
+        format!("hash_{:x}", sum)
     }
 }
 
diff --git a/src/merkletree.rs b/src/merkletree.rs
index 9d2ff84..0d5186b 100644
--- a/src/merkletree.rs
+++ b/src/merkletree.rs
@@ -111,6 +111,11 @@ impl MerkleTree {
         self.leaves.len()
     }
 
+    /// Returns the tree' leaves.
+    pub fn leaves(&self) -> Vec<Node> {
+        self.leaves.clone()
+    }
+
     /// Returns the root node of the tree.
     pub fn root(&self) -> Node {
         self.root.clone()
@@ -121,7 +126,6 @@ impl MerkleTree {
 mod tests {
     use super::*;
     use crate::hasher::*;
-    use crate::proof::*;
 
     #[test]
     fn test_merkle_tree_with_default_hasher() {
@@ -129,7 +133,7 @@ mod tests {
         let tree = MerkleTree::new(DummyHasher, data);
 
         assert_eq!(tree.height(), 2);
-        assert_eq!(tree.root().hash(), "0xc0ff3");
+        assert_eq!(tree.root().hash(), "hash_539");
     }
 
     #[test]
@@ -178,32 +182,4 @@ mod tests {
             "9da1ff0dfa79217bdbea9ec96407b1e693646cc493f64059fa27182a37cadf94"
         );
     }
-
-    #[test]
-    fn test_proof_generation_and_verification_dummy() {
-        let hasher = DummyHasher;
-        let data = vec!["a", "b", "c", "d"];
-        let tree = MerkleTree::new(hasher.clone(), data.clone());
-        let proofer = DefaultProofer::new(hasher.clone(), tree.leaves.clone());
-
-        for (index, item) in data.iter().enumerate() {
-            let proof = proofer.generate(index).unwrap();
-
-            assert!(proofer.verify(&proof, item, tree.root().hash(), &hasher));
-        }
-    }
-    #[test]
-    #[cfg(feature = "sha256")]
-    fn test_proof_generation_and_verification_sha256() {
-        let hasher = SHA256Hasher::new();
-        let data = vec!["a", "b", "c", "d"];
-        let tree = MerkleTree::new(hasher.clone(), data.clone());
-        let proofer = DefaultProofer::new(hasher.clone(), tree.leaves.clone());
-
-        for (index, item) in data.iter().enumerate() {
-            let proof = proofer.generate(index).unwrap();
-
-            assert!(proofer.verify(&proof, item, tree.root().hash(), &hasher));
-        }
-    }
 }
diff --git a/src/proof.rs b/src/proof.rs
index 8f338d7..d2d1c0f 100644
--- a/src/proof.rs
+++ b/src/proof.rs
@@ -58,21 +58,18 @@ pub trait Proofer {
         T: AsRef<[u8]>;
 }
 
-pub struct DefaultProofer {
-    hasher: Box<dyn Hasher>,
+pub struct DefaultProofer<'a> {
+    hasher: &'a dyn Hasher,
     leaves: Vec<Node>,
 }
 
-impl DefaultProofer {
-    pub fn new<H: Hasher + 'static>(hasher: H, leaves: Vec<Node>) -> Self {
-        Self {
-            hasher: Box::new(hasher),
-            leaves,
-        }
+impl<'a> DefaultProofer<'a> {
+    pub fn new(hasher: &'a dyn Hasher, leaves: Vec<Node>) -> Self {
+        Self { hasher, leaves }
     }
 }
 
-impl Proofer for DefaultProofer {
+impl Proofer for DefaultProofer<'_> {
     fn generate(&self, index: usize) -> Option<MerkleProof> {
         if index >= self.leaves.len() {
             return None;
@@ -148,3 +145,39 @@ impl Proofer for DefaultProofer {
         current_hash == root_hash
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{hasher::*, merkletree::MerkleTree};
+
+    use super::*;
+
+    #[test]
+    fn test_proof_generation_and_verification_dummy() {
+        let hasher = DummyHasher;
+        let data = vec!["a", "b", "c", "d"];
+        let tree = MerkleTree::new(hasher.clone(), data.clone());
+        let proofer = DefaultProofer::new(&hasher, tree.leaves());
+
+        for (index, item) in data.iter().enumerate() {
+            let proof = proofer.generate(index).unwrap();
+
+            assert!(proofer.verify(&proof, item, tree.root().hash(), &hasher));
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "sha256")]
+    fn test_proof_generation_and_verification_sha256() {
+        let hasher = SHA256Hasher::new();
+        let data = vec!["a", "b", "c", "d"];
+        let tree = MerkleTree::new(hasher.clone(), data.clone());
+        let proofer = DefaultProofer::new(&hasher, tree.leaves().clone());
+
+        for (index, item) in data.iter().enumerate() {
+            let proof = proofer.generate(index).unwrap();
+
+            assert!(proofer.verify(&proof, item, tree.root().hash(), &hasher));
+        }
+    }
+}