feat: various helper functions and fixes for platform contested resources PR

costs/src/lib.rs

@@ -93,6 +93,11 @@ pub struct OperationCost {
 }
 
 impl OperationCost {
+    /// Is Nothing
+    pub fn is_nothing(&self) -> bool {
+        self == &Self::default()
+    }
+
     /// Helper function to build default `OperationCost` with different
     /// `seek_count`.
     pub fn with_seek_count(seek_count: u16) -> Self {

grovedb/Cargo.toml

@@ -17,7 +17,7 @@ tempfile = { version = "3.10.1", optional = true }
 bincode = { version = "2.0.0-rc.3" }
 grovedb-storage = { version = "1.0.0-rc.2", path = "../storage", optional = true }
 grovedb-visualize = { version = "1.0.0-rc.2", path = "../visualize", optional = true }
-hex = { version = "0.4.3", optional = true }
+hex = { version = "0.4.3"}
 itertools = { version = "0.12.1", optional = true }
 integer-encoding = { version = "4.0.0", optional = true }
 grovedb-costs = { version = "1.0.0-rc.2", path = "../costs", optional = true }
@@ -51,7 +51,6 @@ full = [
     "tempfile",
     "grovedb-storage/rocksdb_storage",
     "visualize",
-    "hex",
     "itertools",
     "integer-encoding",
     "grovedb-costs",

grovedb/src/batch/estimated_costs/average_case_costs.rs

@@ -228,7 +228,7 @@
             .estimated_to_be_empty();
 
         // Then we have to get the tree
         if self.cached_merks.get(path).is_none() {
             let layer_info = cost_return_on_error_no_add!(
                 &cost,
                 self.paths.get(path).ok_or_else(|| {
@@ -274,18 +274,18 @@
         let base_path = KeyInfoPath(vec![]);
         if let Some(estimated_layer_info) = self.paths.get(&base_path) {
             // Then we have to get the tree
-            if self.cached_merks.get(&base_path).is_none() {
+            if !self.cached_merks.contains_key(&base_path) {
                 GroveDb::add_average_case_get_merk_at_path::<RocksDbStorage>(
                     &mut cost,
                     &base_path,
                     estimated_layer_info
                         .estimated_layer_count
                         .estimated_to_be_empty(),
                     estimated_layer_info.is_sum_tree,
                 );
                 self.cached_merks
                     .insert(base_path, estimated_layer_info.is_sum_tree);
             }
         }
         Ok(()).wrap_with_cost(cost)
     }

grovedb/src/batch/estimated_costs/worst_case_costs.rs

@@ -214,7 +214,7 @@ impl<G, SR> TreeCache<G, SR> for WorstCaseTreeCacheKnownPaths {
         );
 
         // Then we have to get the tree
-        if self.cached_merks.get(path).is_none() {
+        if !self.cached_merks.contains(path) {
             GroveDb::add_worst_case_get_merk_at_path::<RocksDbStorage>(&mut cost, path, false);
             self.cached_merks.insert(path.clone());
         }
@@ -239,7 +239,7 @@ impl<G, SR> TreeCache<G, SR> for WorstCaseTreeCacheKnownPaths {
         let base_path = KeyInfoPath(vec![]);
         if let Some(_estimated_layer_info) = self.paths.get(&base_path) {
             // Then we have to get the tree
-            if self.cached_merks.get(&base_path).is_none() {
+            if !self.cached_merks.contains(&base_path) {
                 GroveDb::add_worst_case_get_merk_at_path::<RocksDbStorage>(
                     &mut cost, &base_path, false,
                 );

grovedb/src/debugger.rs

@@ -1,6 +1,6 @@
 //! GroveDB debugging support module.
 
 use std::{fs, net::Ipv4Addr, sync::Weak};
 
 use axum::{extract::State, http::StatusCode, response::IntoResponse, routing::post, Json, Router};
 use grovedb_merk::debugger::NodeDbg;
@@ -27,7 +27,7 @@
         let grovedbg_zip = grovedbg_tmp.path().join("grovedbg.zip");
         let grovedbg_www = grovedbg_tmp.path().join("grovedbg_www");
 
         fs::write(&grovedbg_zip, &GROVEDBG_ZIP).expect("cannot crate grovedbg.zip");
         zip_extensions::read::zip_extract(&grovedbg_zip, &grovedbg_www)
             .expect("cannot extract grovedbg contents");
 
@@ -144,6 +144,16 @@
             n_keep: n_keep.into(),
             path_append,
         },
+        crate::Element::Reference(
+            ReferencePathType::UpstreamRootHeightWithParentPathAdditionReference(
+                n_keep,
+                path_append,
+            ),
+            ..,
+        ) => grovedbg_types::Element::UpstreamRootHeightWithParentPathAdditionReference {
+            n_keep: n_keep.into(),
+            path_append,
+        },
         crate::Element::Reference(
             ReferencePathType::UpstreamFromElementHeightReference(n_remove, path_append),
             ..,

grovedb/src/element/get.rs

@@ -59,8 +59,12 @@ impl Element {
             let value = result?;
             value.ok_or_else(|| {
                 Error::PathKeyNotFound(format!(
-                    "key not found in Merk for get: {}",
-                    hex::encode(key)
+                    "get: key \"{}\" not found in Merk that has a root key [{}] and is of type {}",
+                    hex::encode(key),
+                    merk.root_key()
+                        .map(hex::encode)
+                        .unwrap_or("None".to_string()),
+                    merk.merk_type
                 ))
             })
         })

grovedb/src/element/helpers.rs

@@ -43,12 +43,13 @@
 #[cfg(feature = "full")]
 use integer_encoding::VarInt;
 
+#[cfg(any(feature = "full", feature = "verify"))]
+use crate::reference_path::{path_from_reference_path_type, ReferencePathType};
 #[cfg(any(feature = "full", feature = "verify"))]
 use crate::{element::SUM_ITEM_COST_SIZE, Element, Error};
 #[cfg(feature = "full")]
 use crate::{
     element::{SUM_TREE_COST_SIZE, TREE_COST_SIZE},
-    reference_path::{path_from_reference_path_type, ReferencePathType},
     ElementFlags,
 };
 
@@ -64,15 +65,41 @@
     }
 
     #[cfg(any(feature = "full", feature = "verify"))]
-    /// Decoded the integer value in the SumItem element type, returns 0 for
-    /// everything else
+    /// Decoded the integer value in the SumItem element type
     pub fn as_sum_item_value(&self) -> Result<i64, Error> {
         match self {
             Element::SumItem(value, _) => Ok(*value),
             _ => Err(Error::WrongElementType("expected a sum item")),
         }
     }
 
+    #[cfg(any(feature = "full", feature = "verify"))]
+    /// Decoded the integer value in the SumItem element type
+    pub fn into_sum_item_value(self) -> Result<i64, Error> {
+        match self {
+            Element::SumItem(value, _) => Ok(value),
+            _ => Err(Error::WrongElementType("expected a sum item")),
+        }
+    }
+
+    #[cfg(any(feature = "full", feature = "verify"))]
+    /// Decoded the integer value in the SumTree element type
+    pub fn as_sum_tree_value(&self) -> Result<i64, Error> {
+        match self {
+            Element::SumTree(_, value, _) => Ok(*value),
+            _ => Err(Error::WrongElementType("expected a sum tree")),
+        }
+    }
+
+    #[cfg(any(feature = "full", feature = "verify"))]
+    /// Decoded the integer value in the SumTree element type
+    pub fn into_sum_tree_value(self) -> Result<i64, Error> {
+        match self {
+            Element::SumTree(_, value, _) => Ok(value),
+            _ => Err(Error::WrongElementType("expected a sum tree")),
+        }
+    }
+
     #[cfg(any(feature = "full", feature = "verify"))]
     /// Gives the item value in the Item element type
     pub fn as_item_bytes(&self) -> Result<&[u8], Error> {
@@ -91,6 +118,15 @@
         }
     }
 
+    #[cfg(any(feature = "full", feature = "verify"))]
+    /// Gives the reference path type in the Reference element type
+    pub fn into_reference_path_type(self) -> Result<ReferencePathType, Error> {
+        match self {
+            Element::Reference(value, ..) => Ok(value),
+            _ => Err(Error::WrongElementType("expected a reference")),
+        }
+    }
+
     #[cfg(any(feature = "full", feature = "verify"))]
     /// Check if the element is a sum tree
     pub fn is_sum_tree(&self) -> bool {
@@ -103,6 +139,12 @@
         matches!(self, Element::SumTree(..) | Element::Tree(..))
     }
 
+    #[cfg(any(feature = "full", feature = "verify"))]
+    /// Check if the element is a reference
+    pub fn is_reference(&self) -> bool {
+        matches!(self, Element::Reference(..))
+    }
+
     #[cfg(any(feature = "full", feature = "verify"))]
     /// Check if the element is an item
     pub fn is_item(&self) -> bool {
@@ -245,7 +287,7 @@
     #[cfg(feature = "full")]
     /// Get tree costs for a key value
     pub fn specialized_costs_for_key_value(
         key: &Vec<u8>,
         value: &[u8],
         is_sum_node: bool,
     ) -> Result<u32, Error> {
@@ -316,9 +358,9 @@
     #[cfg(feature = "full")]
     /// Get the value defined cost for a serialized value
     pub fn value_defined_cost(&self) -> Option<ValueDefinedCostType> {
         let Some(value_cost) = self.get_specialized_cost().ok() else {
             return None;
         };
 
         let cost = value_cost
             + self.get_flags().as_ref().map_or(0, |flags| {

grovedb/src/element/mod.rs

@@ -101,7 +101,7 @@ pub enum Element {
     Item(Vec<u8>, Option<ElementFlags>),
     /// A reference to an object by its path
     Reference(ReferencePathType, MaxReferenceHop, Option<ElementFlags>),
-    /// A subtree, contains the a prefixed key representing the root of the
+    /// A subtree, contains the prefixed key representing the root of the
     /// subtree.
     Tree(Option<Vec<u8>>, Option<ElementFlags>),
     /// Signed integer value that can be totaled in a sum tree
@@ -111,6 +111,18 @@ pub enum Element {
     SumTree(Option<Vec<u8>>, SumValue, Option<ElementFlags>),
 }
 
+impl Element {
+    pub fn type_str(&self) -> &str {
+        match self {
+            Element::Item(..) => "item",
+            Element::Reference(..) => "reference",
+            Element::Tree(..) => "tree",
+            Element::SumItem(..) => "sum item",
+            Element::SumTree(..) => "sum tree",
+        }
+    }
+}
+
 #[cfg(any(feature = "full", feature = "visualize"))]
 impl fmt::Debug for Element {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

grovedb/src/element/query.rs

@@ -53,7 +53,7 @@
             QueryPathKeyElementTrioResultType,
         },
     },
-    util::{merk_optional_tx, storage_context_optional_tx},
+    util::{merk_optional_tx, merk_optional_tx_internal_error, storage_context_optional_tx},
     Error, PathQuery, TransactionArg,
 };
 #[cfg(any(feature = "full", feature = "verify"))]
@@ -543,19 +543,19 @@
     /// expensive query.
     #[cfg(feature = "full")]
     // TODO: refactor
     fn query_item(
         storage: &RocksDbStorage,
         item: &QueryItem,
         results: &mut Vec<QueryResultElement>,
         path: &[&[u8]],
         sized_query: &SizedQuery,
         transaction: TransactionArg,
         limit: &mut Option<u16>,
         offset: &mut Option<u16>,
         query_options: QueryOptions,
         result_type: QueryResultType,
         add_element_function: fn(PathQueryPushArgs) -> CostResult<(), Error>,
     ) -> CostResult<(), Error> {
         let mut cost = OperationCost::default();
 
         let subtree_path: SubtreePath<_> = path.into();
@@ -563,7 +563,7 @@
         if !item.is_range() {
             // this is a query on a key
             if let QueryItem::Key(key) = item {
-                let element_res = merk_optional_tx!(
+                let element_res = merk_optional_tx_internal_error!(
                     &mut cost,
                     storage,
                     subtree_path,

grovedb/src/error.rs

@@ -19,7 +19,7 @@ pub enum Error {
     InternalError(&'static str),
     #[error("invalid proof: {0}")]
     /// Invalid proof
-    InvalidProof(&'static str),
+    InvalidProof(String),
     #[error("invalid input: {0}")]
     /// Invalid input
     InvalidInput(&'static str),

grovedb/src/lib.rs

@@ -164,7 +164,6 @@
 mod tests;
 #[cfg(feature = "full")]
 mod util;
-#[cfg(any(feature = "full", feature = "verify"))]
 mod versioning;
 #[cfg(feature = "full")]
 mod visualize;
@@ -336,11 +335,11 @@
 
     /// Opens a Merk at given path for with direct write access. Intended for
     /// replication purposes.
-    fn open_merk_for_replication<'db, 'b, B>(
+    fn open_merk_for_replication<'tx, 'db: 'tx, 'b, B>(
         &'db self,
         path: SubtreePath<'b, B>,
-        tx: &'db Transaction,
-    ) -> Result<Merk<PrefixedRocksDbImmediateStorageContext<'db>>, Error>
+        tx: &'tx Transaction<'db>,
+    ) -> Result<Merk<PrefixedRocksDbImmediateStorageContext<'tx>>, Error>
     where
         B: AsRef<[u8]> + 'b,
     {
@@ -859,7 +858,7 @@
     pub fn verify_grovedb(
         &self,
         transaction: TransactionArg,
     ) -> Result<HashMap<Vec<Vec<u8>>, (CryptoHash, CryptoHash, CryptoHash)>, Error> {
         if let Some(transaction) = transaction {
             let root_merk = self
                 .open_transactional_merk_at_path(SubtreePath::empty(), transaction, None)
@@ -885,7 +884,7 @@
         merk: Merk<S>,
         path: &SubtreePath<B>,
         batch: Option<&'db StorageBatch>,
     ) -> Result<HashMap<Vec<Vec<u8>>, (CryptoHash, CryptoHash, CryptoHash)>, Error> {
         let mut all_query = Query::new();
         all_query.insert_all();
 
@@ -955,7 +954,7 @@
         path: &SubtreePath<B>,
         batch: Option<&'db StorageBatch>,
         transaction: &Transaction,
     ) -> Result<HashMap<Vec<Vec<u8>>, (CryptoHash, CryptoHash, CryptoHash)>, Error> {
         let mut all_query = Query::new();
         all_query.insert_all();
 

grovedb/src/operations.rs

@@ -40,3 +40,6 @@ pub mod insert;
 pub(crate) mod is_empty_tree;
 #[cfg(any(feature = "full", feature = "verify"))]
 pub mod proof;
+
+#[cfg(feature = "full")]
+pub use get::{QueryItemOrSumReturnType, MAX_REFERENCE_HOPS};

grovedb/src/operations/get/mod.rs

@@ -32,6 +32,8 @@
 mod average_case;
 #[cfg(feature = "full")]
 mod query;
+#[cfg(feature = "full")]
+pub use query::QueryItemOrSumReturnType;
 #[cfg(feature = "estimated_costs")]
 mod worst_case;