feat: add Element::ProvableCountProvableSumTree + dual-axis crossover proofs

grovedb-bulk-append-tree/src/proof/mod.rs

@@ -149,6 +149,13 @@ fn query_to_ranges(query: &Query, total_count: u64) -> Result<Vec<(u64, u64)>, B
                         .into(),
                 ));
             }
+            QueryItem::AggregateCountAndSumOnRange(_) => {
+                return Err(BulkAppendError::InvalidInput(
+                    "AggregateCountAndSumOnRange is only supported on \
+                     ProvableCountProvableSumTree, not on BulkAppendTree"
+                        .into(),
+                ));
+            }
         };
         ranges.push((start, end));
     }

grovedb-dense-fixed-sized-merkle-tree/src/proof/mod.rs

@@ -130,6 +130,13 @@ pub(crate) fn query_to_positions(query: &Query, count: u16) -> Result<Vec<u16>,
                         .into(),
                 ));
             }
+            QueryItem::AggregateCountAndSumOnRange(_) => {
+                return Err(DenseMerkleError::InvalidProof(
+                    "AggregateCountAndSumOnRange is only supported on \
+                     ProvableCountProvableSumTree, not on dense fixed-size merkle trees"
+                        .into(),
+                ));
+            }
         }
     }
 

grovedb-element/src/element/constructor.rs

@@ -365,6 +365,47 @@ impl Element {
         Element::ProvableSumTree(maybe_root_key, sum_value, flags)
     }
 
+    /// Set element to default empty provable count provable sum tree without
+    /// flags.
+    ///
+    /// `ProvableCountProvableSumTree` bakes BOTH the per-node count AND the
+    /// per-node sum into the node hash, enabling both
+    /// `AggregateCountOnRange` and `AggregateSumOnRange` proofs against the
+    /// same tree.
+    pub fn empty_provable_count_provable_sum_tree() -> Self {
+        Element::new_provable_count_provable_sum_tree(Default::default())
+    }
+
+    /// Set element to default empty provable count provable sum tree with
+    /// flags.
+    pub fn empty_provable_count_provable_sum_tree_with_flags(flags: Option<ElementFlags>) -> Self {
+        Element::new_provable_count_provable_sum_tree_with_flags(Default::default(), flags)
+    }
+
+    /// Set element to a provable count provable sum tree without flags.
+    pub fn new_provable_count_provable_sum_tree(maybe_root_key: Option<Vec<u8>>) -> Self {
+        Element::ProvableCountProvableSumTree(maybe_root_key, 0, 0, None)
+    }
+
+    /// Set element to a provable count provable sum tree with flags.
+    pub fn new_provable_count_provable_sum_tree_with_flags(
+        maybe_root_key: Option<Vec<u8>>,
+        flags: Option<ElementFlags>,
+    ) -> Self {
+        Element::ProvableCountProvableSumTree(maybe_root_key, 0, 0, flags)
+    }
+
+    /// Set element to a provable count provable sum tree with flags, count,
+    /// and sum value.
+    pub fn new_provable_count_provable_sum_tree_with_flags_and_sum_and_count_value(
+        maybe_root_key: Option<Vec<u8>>,
+        count_value: CountValue,
+        sum_value: SumValue,
+        flags: Option<ElementFlags>,
+    ) -> Self {
+        Element::ProvableCountProvableSumTree(maybe_root_key, count_value, sum_value, flags)
+    }
+
     /// Set element to an empty commitment tree.
     ///
     /// Returns `InvalidInput` if `chunk_power > 31`.
@@ -515,22 +556,24 @@ impl Element {
     /// parent sum tree's running sum when inserted. Counts (if any) still
     /// propagate.
     ///
-    /// Only the five sum-bearing tree variants are accepted: `SumTree`,
+    /// Only the six sum-bearing tree variants are accepted: `SumTree`,
     /// `BigSumTree`, `CountSumTree`, `ProvableCountSumTree`,
-    /// `ProvableSumTree`. Any other element — including items, sum items,
-    /// references, non-sum trees, and any wrapper (`NonCounted`,
-    /// `NotSummed`, `NotCountedOrSummed`) — is rejected with
-    /// `InvalidInput`.
+    /// `ProvableSumTree`, `ProvableCountProvableSumTree`. Any other
+    /// element — including items, sum items, references, non-sum trees, and
+    /// any wrapper (`NonCounted`, `NotSummed`, `NotCountedOrSummed`) — is
+    /// rejected with `InvalidInput`.
     pub fn new_not_summed(inner: Element) -> Result<Self, ElementError> {
         match inner {
             Element::SumTree(..)
             | Element::BigSumTree(..)
             | Element::CountSumTree(..)
             | Element::ProvableCountSumTree(..)
-            | Element::ProvableSumTree(..) => Ok(Element::NotSummed(Box::new(inner))),
+            | Element::ProvableSumTree(..)
+            | Element::ProvableCountProvableSumTree(..) => Ok(Element::NotSummed(Box::new(inner))),
             _ => Err(ElementError::InvalidInput(
                 "NotSummed inner element must be a sum-tree variant (SumTree, BigSumTree, \
-                 CountSumTree, ProvableCountSumTree, or ProvableSumTree)",
+                 CountSumTree, ProvableCountSumTree, ProvableSumTree, or \
+                 ProvableCountProvableSumTree)",
             )),
         }
     }
@@ -563,27 +606,33 @@ impl Element {
     /// to BOTH its parent's running sum AND its parent's count when
     /// inserted.
     ///
-    /// Only the five sum-bearing tree variants are accepted: `SumTree`,
+    /// Only the six sum-bearing tree variants are accepted: `SumTree`,
     /// `BigSumTree`, `CountSumTree`, `ProvableCountSumTree`,
-    /// `ProvableSumTree`. Any other element — including items, sum items,
-    /// references, non-sum trees, and any wrapper (`NonCounted`,
-    /// `NotSummed`, `NotCountedOrSummed`) — is rejected with
-    /// `InvalidInput`.
+    /// `ProvableSumTree`, `ProvableCountProvableSumTree`. Any other
+    /// element — including items, sum items, references, non-sum trees, and
+    /// any wrapper (`NonCounted`, `NotSummed`, `NotCountedOrSummed`) — is
+    /// rejected with `InvalidInput`.
     ///
     /// Note: at insert time the parent must be `CountSumTree`. Provable
-    /// count-and-sum parents (`ProvableCountSumTree`) reject the wrapper
-    /// at the merk-layer insert guard — they cryptographically commit the
-    /// count into every node hash and must reflect actual contents.
+    /// count-and-sum parents (`ProvableCountSumTree`,
+    /// `ProvableCountProvableSumTree`) reject the wrapper at the
+    /// merk-layer insert guard — they cryptographically commit the
+    /// count (and, for PCPS, the sum) into every node hash and must
+    /// reflect actual contents.
     pub fn new_not_counted_or_summed(inner: Element) -> Result<Self, ElementError> {
         match inner {
             Element::SumTree(..)
             | Element::BigSumTree(..)
             | Element::CountSumTree(..)
             | Element::ProvableCountSumTree(..)
-            | Element::ProvableSumTree(..) => Ok(Element::NotCountedOrSummed(Box::new(inner))),
+            | Element::ProvableSumTree(..)
+            | Element::ProvableCountProvableSumTree(..) => {
+                Ok(Element::NotCountedOrSummed(Box::new(inner)))
+            }
             _ => Err(ElementError::InvalidInput(
                 "NotCountedOrSummed inner element must be a sum-bearing tree variant (SumTree, \
-                 BigSumTree, CountSumTree, ProvableCountSumTree, or ProvableSumTree)",
+                 BigSumTree, CountSumTree, ProvableCountSumTree, ProvableSumTree, or \
+                 ProvableCountProvableSumTree)",
             )),
         }
     }

grovedb-element/src/element/helpers.rs

@@ -101,6 +101,7 @@ impl Element {
             | Element::CountSumTree(_, _, sum_value, _)
             | Element::ProvableCountSumTree(_, _, sum_value, _)
             | Element::ProvableSumTree(_, sum_value, _)
+            | Element::ProvableCountProvableSumTree(_, _, sum_value, _)
             | Element::ReferenceWithSumItem(_, _, sum_value, _) => *sum_value,
             _ => 0,
         }
@@ -119,7 +120,8 @@ impl Element {
             Element::CountTree(_, count_value, _)
             | Element::CountSumTree(_, count_value, ..)
             | Element::ProvableCountTree(_, count_value, _)
-            | Element::ProvableCountSumTree(_, count_value, ..) => *count_value,
+            | Element::ProvableCountSumTree(_, count_value, ..)
+            | Element::ProvableCountProvableSumTree(_, count_value, ..) => *count_value,
             _ => 1,
         }
     }
@@ -146,7 +148,8 @@ impl Element {
             | Element::ReferenceWithSumItem(_, _, sum_value, _) => (1, *sum_value),
             Element::CountTree(_, count_value, _) => (*count_value, 0),
             Element::CountSumTree(_, count_value, sum_value, _)
-            | Element::ProvableCountSumTree(_, count_value, sum_value, _) => {
+            | Element::ProvableCountSumTree(_, count_value, sum_value, _)
+            | Element::ProvableCountProvableSumTree(_, count_value, sum_value, _) => {
                 (*count_value, *sum_value)
             }
             Element::ProvableCountTree(_, count_value, _) => (*count_value, 0),
@@ -168,6 +171,7 @@ impl Element {
             | Element::CountSumTree(_, _, sum_value, _)
             | Element::ProvableCountSumTree(_, _, sum_value, _)
             | Element::ProvableSumTree(_, sum_value, _)
+            | Element::ProvableCountProvableSumTree(_, _, sum_value, _)
             | Element::ReferenceWithSumItem(_, _, sum_value, _) => *sum_value as i128,
             Element::BigSumTree(_, sum_value, _) => *sum_value,
             _ => 0,
@@ -282,6 +286,33 @@ impl Element {
         }
     }
 
+    /// Check if the element is a `ProvableCountProvableSumTree`. Looks through
+    /// wrappers.
+    pub fn is_provable_count_provable_sum_tree(&self) -> bool {
+        matches!(self.underlying(), Element::ProvableCountProvableSumTree(..))
+    }
+
+    /// Decoded (count, sum) from a `ProvableCountProvableSumTree`. Looks
+    /// through wrappers.
+    pub fn as_provable_count_provable_sum_tree_value(&self) -> Result<(u64, i64), ElementError> {
+        match self.underlying() {
+            Element::ProvableCountProvableSumTree(_, count, sum, _) => Ok((*count, *sum)),
+            _ => Err(ElementError::WrongElementType(
+                "expected a provable count provable sum tree",
+            )),
+        }
+    }
+
+    /// Owned variant of [`as_provable_count_provable_sum_tree_value`].
+    pub fn into_provable_count_provable_sum_tree_value(self) -> Result<(u64, i64), ElementError> {
+        match self.into_underlying() {
+            Element::ProvableCountProvableSumTree(_, count, sum, _) => Ok((count, sum)),
+            _ => Err(ElementError::WrongElementType(
+                "expected a provable count provable sum tree",
+            )),
+        }
+    }
+
     /// Check if the element is a tree but not a sum tree. Looks through
     /// `NonCounted`.
     pub fn is_basic_tree(&self) -> bool {
@@ -300,6 +331,7 @@ impl Element {
                 | Element::ProvableCountTree(..)
                 | Element::ProvableCountSumTree(..)
                 | Element::ProvableSumTree(..)
+                | Element::ProvableCountProvableSumTree(..)
                 | Element::CommitmentTree(..)
                 | Element::MmrTree(..)
                 | Element::BulkAppendTree(..)
@@ -379,6 +411,7 @@ impl Element {
                 | Element::ProvableCountTree(Some(_), ..)
                 | Element::ProvableCountSumTree(Some(_), ..)
                 | Element::ProvableSumTree(Some(_), ..)
+                | Element::ProvableCountProvableSumTree(Some(_), ..)
                 | Element::CommitmentTree(..)
                 | Element::MmrTree(..)
                 | Element::BulkAppendTree(..)
@@ -404,6 +437,7 @@ impl Element {
                 | Element::ProvableCountTree(Some(_), ..)
                 | Element::ProvableCountSumTree(Some(_), ..)
                 | Element::ProvableSumTree(Some(_), ..)
+                | Element::ProvableCountProvableSumTree(Some(_), ..)
         )
     }
 
@@ -478,6 +512,7 @@ impl Element {
             | Element::ProvableCountTree(.., flags)
             | Element::ProvableCountSumTree(.., flags)
             | Element::ProvableSumTree(.., flags)
+            | Element::ProvableCountProvableSumTree(.., flags)
             | Element::ItemWithSumItem(.., flags)
             | Element::CommitmentTree(.., flags)
             | Element::MmrTree(.., flags)
@@ -505,6 +540,7 @@ impl Element {
             | Element::ProvableCountTree(.., flags)
             | Element::ProvableCountSumTree(.., flags)
             | Element::ProvableSumTree(.., flags)
+            | Element::ProvableCountProvableSumTree(.., flags)
             | Element::ItemWithSumItem(.., flags)
             | Element::CommitmentTree(.., flags)
             | Element::MmrTree(.., flags)
@@ -532,6 +568,7 @@ impl Element {
             | Element::ProvableCountTree(.., flags)
             | Element::ProvableCountSumTree(.., flags)
             | Element::ProvableSumTree(.., flags)
+            | Element::ProvableCountProvableSumTree(.., flags)
             | Element::ItemWithSumItem(.., flags)
             | Element::CommitmentTree(.., flags)
             | Element::MmrTree(.., flags)
@@ -559,6 +596,7 @@ impl Element {
             | Element::ProvableCountTree(.., flags)
             | Element::ProvableCountSumTree(.., flags)
             | Element::ProvableSumTree(.., flags)
+            | Element::ProvableCountProvableSumTree(.., flags)
             | Element::ItemWithSumItem(.., flags)
             | Element::CommitmentTree(.., flags)
             | Element::MmrTree(.., flags)