feat: Proof Construction

.gitignore

@@ -1,3 +1,3 @@
 /target
 .idea
-Cargo.lock
+Cargo.lock

grovedb/src/lib.rs

@@ -9,7 +9,7 @@ use std::{
     rc::Rc,
 };
 
-use merk::{self, rocksdb, Merk};
+use merk::{self, proofs::Query, rocksdb, Merk};
 use rs_merkle::{algorithms::Sha256, MerkleTree};
 use subtree::Element;
 
@@ -231,8 +231,38 @@ impl GroveDb {
         Err(Error::ReferenceLimit)
     }
 
-    pub fn proof(&self) -> ! {
-        todo!()
+    pub fn proof(&self, path: &[&[u8]], key: &[u8]) -> Result<Vec<Vec<u8>>, Error> {
+        let mut split_path = Some((&key, path));
+        let mut proofs: Vec<Vec<u8>> = Vec::new();
+
+        while let Some((key, path_slice)) = split_path {
+            if path_slice.is_empty() {
+                // Get proof for root tree at current key
+                let root_key_index = self
+                    .root_leaf_keys
+                    .get(*key)
+                    .ok_or(Error::InvalidPath("root key not found"))?;
+                proofs.push(self.root_tree.proof(&[*root_key_index]).to_bytes());
+            } else {
+                let merk = self
+                    .subtrees
+                    .get(&Self::compress_path(path_slice, None))
+                    .ok_or(Error::InvalidPath("no subtree found under that path"))?;
+
+                // Generate a proof for this merk at the given key
+                let mut proof_query = Query::new();
+                proof_query.insert_key(key.to_vec());
+
+                let proof_result = merk
+                    .prove(proof_query)
+                    .expect("should prove both inclusion and absence");
+
+                proofs.push(proof_result);
+            }
+            split_path = path_slice.split_last();
+        }
+
+        Ok(proofs)
     }
 
     /// Method to propagate updated subtree root hashes up to GroveDB root

grovedb/src/tests.rs

@@ -1,5 +1,6 @@
 use std::ops::{Deref, DerefMut};
 
+use merk::test_utils::TempMerk;
 use tempdir::TempDir;
 
 use super::*;
@@ -239,3 +240,52 @@ fn test_root_tree_leafs_are_noted() {
     assert_eq!(db.root_leaf_keys, hm);
     assert_eq!(db.root_tree.leaves_len(), 2);
 }
+
+#[test]
+fn test_proof_construction() {
+    let mut temp_db = make_grovedb();
+    temp_db
+        .insert(&[TEST_LEAF], b"innertree".to_vec(), Element::empty_tree())
+        .expect("successful subtree insert");
+    temp_db
+        .insert(
+            &[TEST_LEAF, b"innertree"],
+            b"key1".to_vec(),
+            Element::Item(b"value1".to_vec()),
+        )
+        .expect("successful item insert");
+
+    // Manually build the ads structures
+    let mut inner_tree_merk = TempMerk::new();
+    let value_element = Element::Item(b"value1".to_vec());
+    value_element.insert(&mut inner_tree_merk, b"key1".to_vec());
+
+    let mut test_leaf_merk = TempMerk::new();
+    let inner_tree_root_element = Element::Tree(inner_tree_merk.root_hash());
+    inner_tree_root_element.insert(&mut test_leaf_merk, b"innertree".to_vec());
+
+    let another_test_leaf_merk = TempMerk::new();
+
+    let leaves = [
+        test_leaf_merk.root_hash(),
+        another_test_leaf_merk.root_hash(),
+    ];
+    let root_tree = MerkleTree::<Sha256>::from_leaves(&leaves);
+
+    // Generate groove db proof
+    let proof = temp_db
+        .proof(&[TEST_LEAF, b"innertree"], b"key1")
+        .expect("Successful proof generation");
+
+    assert_eq!(proof.len(), 3);
+
+    let mut proof_query = Query::new();
+    proof_query.insert_key(b"key1".to_vec());
+    assert_eq!(proof[0], inner_tree_merk.prove(proof_query).unwrap());
+
+    let mut proof_query = Query::new();
+    proof_query.insert_key(b"innertree".to_vec());
+    assert_eq!(proof[1], test_leaf_merk.prove(proof_query).unwrap());
+
+    assert_eq!(proof[2], root_tree.proof(&vec![0]).to_bytes());
+}