Revert #115

src/binary/in_memory.rs

@@ -128,7 +128,7 @@ mod test {
     }
 
     #[test]
-    fn prove_returns_the_merkle_root_and_empty_proof_set_for_1_leaf() {
+    fn prove_returns_the_merkle_root_and_proof_set_for_1_leaf() {
         let mut tree = MerkleTree::new();
 
         let data = &TEST_DATA[0..1]; // 1 leaf
@@ -144,7 +144,7 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, leaf_0);
-            assert_eq!(set, ProofSet::default());
+            assert_eq!(set[0], leaf_0);
         }
     }
 
@@ -193,68 +193,75 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_1);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_0);
+            assert_eq!(set[1], leaf_1);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(1).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_0);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_1);
+            assert_eq!(set[1], leaf_0);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(2).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_3);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_2);
+            assert_eq!(set[1], leaf_3);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(3).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_2);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_3);
+            assert_eq!(set[1], leaf_2);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(4).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_5);
-            assert_eq!(set[1], leaf_6);
-            assert_eq!(set[2], node_3);
+            assert_eq!(set[0], leaf_4);
+            assert_eq!(set[1], leaf_5);
+            assert_eq!(set[2], leaf_6);
+            assert_eq!(set[3], node_3);
         }
         {
             let proof = tree.prove(5).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_4);
-            assert_eq!(set[1], leaf_6);
-            assert_eq!(set[2], node_3);
+            assert_eq!(set[0], leaf_5);
+            assert_eq!(set[1], leaf_4);
+            assert_eq!(set[2], leaf_6);
+            assert_eq!(set[3], node_3);
         }
         {
             let proof = tree.prove(6).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], node_9);
-            assert_eq!(set[1], node_3);
+            assert_eq!(set[0], leaf_6);
+            assert_eq!(set[1], node_9);
+            assert_eq!(set[2], node_3);
         }
     }
 }

src/binary/merkle_tree.rs

@@ -98,6 +98,9 @@ where
         let root_node = self.root_node()?.unwrap();
         let root_position = root_node.position();
         let leaf_position = Position::from_leaf_index(proof_index);
+        let leaf_node = self.storage.get(&leaf_position.in_order_index())?.unwrap();
+        proof_set.push(*leaf_node.hash());
+
         let (_, mut side_positions): (Vec<_>, Vec<_>) = root_position
             .path(&leaf_position, self.leaves_count)
             .iter()
@@ -204,7 +207,7 @@ where
 mod test {
     use super::{MerkleTree, NodesTable};
     use crate::binary::{empty_sum, leaf_sum, node_sum};
-    use crate::common::{ProofSet, StorageMap};
+    use crate::common::StorageMap;
     use fuel_merkle_test_helpers::TEST_DATA;
     use fuel_storage::StorageInspect;
 
@@ -404,7 +407,7 @@ mod test {
     }
 
     #[test]
-    fn prove_returns_the_merkle_root_and_empty_proof_set_for_1_leaf() {
+    fn prove_returns_the_merkle_root_and_proof_set_for_1_leaf() {
         let mut storage_map = StorageMap::<NodesTable>::new();
         let mut tree = MerkleTree::new(&mut storage_map);
 
@@ -421,7 +424,7 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, leaf_0);
-            assert_eq!(set, ProofSet::default());
+            assert_eq!(set[0], leaf_0);
         }
     }
 
@@ -458,35 +461,39 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, node_3);
-            assert_eq!(set[0], leaf_1);
-            assert_eq!(set[1], node_5);
+            assert_eq!(set[0], leaf_0);
+            assert_eq!(set[1], leaf_1);
+            assert_eq!(set[2], node_5);
         }
         {
             let proof = tree.prove(1).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_3);
-            assert_eq!(set[0], leaf_0);
-            assert_eq!(set[1], node_5);
+            assert_eq!(set[0], leaf_1);
+            assert_eq!(set[1], leaf_0);
+            assert_eq!(set[2], node_5);
         }
         {
             let proof = tree.prove(2).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_3);
-            assert_eq!(set[0], leaf_3);
-            assert_eq!(set[1], node_1);
+            assert_eq!(set[0], leaf_2);
+            assert_eq!(set[1], leaf_3);
+            assert_eq!(set[2], node_1);
         }
         {
             let proof = tree.prove(3).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_3);
-            assert_eq!(set[0], leaf_2);
-            assert_eq!(set[1], node_1);
+            assert_eq!(set[0], leaf_3);
+            assert_eq!(set[1], leaf_2);
+            assert_eq!(set[2], node_1);
         }
     }
 
@@ -528,47 +535,52 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_1);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], leaf_4);
+            assert_eq!(set[0], leaf_0);
+            assert_eq!(set[1], leaf_1);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], leaf_4);
         }
         {
             let proof = tree.prove(1).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_0);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], leaf_4);
+            assert_eq!(set[0], leaf_1);
+            assert_eq!(set[1], leaf_0);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], leaf_4);
         }
         {
             let proof = tree.prove(2).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_3);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], leaf_4);
+            assert_eq!(set[0], leaf_2);
+            assert_eq!(set[1], leaf_3);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], leaf_4);
         }
         {
             let proof = tree.prove(3).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_2);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], leaf_4);
+            assert_eq!(set[0], leaf_3);
+            assert_eq!(set[1], leaf_2);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], leaf_4);
         }
         {
             let proof = tree.prove(4).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], node_3);
+            assert_eq!(set[0], leaf_4);
+            assert_eq!(set[1], node_3);
         }
     }
 
@@ -618,68 +630,75 @@ mod test {
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_1);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_0);
+            assert_eq!(set[1], leaf_1);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(1).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_0);
-            assert_eq!(set[1], node_5);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_1);
+            assert_eq!(set[1], leaf_0);
+            assert_eq!(set[2], node_5);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(2).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_3);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_2);
+            assert_eq!(set[1], leaf_3);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(3).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_2);
-            assert_eq!(set[1], node_1);
-            assert_eq!(set[2], node_11);
+            assert_eq!(set[0], leaf_3);
+            assert_eq!(set[1], leaf_2);
+            assert_eq!(set[2], node_1);
+            assert_eq!(set[3], node_11);
         }
         {
             let proof = tree.prove(4).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_5);
-            assert_eq!(set[1], leaf_6);
-            assert_eq!(set[2], node_3);
+            assert_eq!(set[0], leaf_4);
+            assert_eq!(set[1], leaf_5);
+            assert_eq!(set[2], leaf_6);
+            assert_eq!(set[3], node_3);
         }
         {
             let proof = tree.prove(5).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], leaf_4);
-            assert_eq!(set[1], leaf_6);
-            assert_eq!(set[2], node_3);
+            assert_eq!(set[0], leaf_5);
+            assert_eq!(set[1], leaf_4);
+            assert_eq!(set[2], leaf_6);
+            assert_eq!(set[3], node_3);
         }
         {
             let proof = tree.prove(6).unwrap();
             let root = proof.0;
             let set = proof.1;
 
             assert_eq!(root, node_7);
-            assert_eq!(set[0], node_9);
-            assert_eq!(set[1], node_3);
+            assert_eq!(set[0], leaf_6);
+            assert_eq!(set[1], node_9);
+            assert_eq!(set[2], node_3);
         }
     }
 }