Enum LowLevelDriveOperation 

pub enum LowLevelDriveOperation {
    GroveOperation(QualifiedGroveDbOp),
    FunctionOperation(FunctionOp),
    CalculatedCostOperation(OperationCost),
    PreCalculatedFeeResult(FeeResult),
}

Drive operation

Variants

GroveOperation(QualifiedGroveDbOp)

Grove operation

FunctionOperation(FunctionOp)

A drive operation

CalculatedCostOperation(OperationCost)

Calculated cost operation

PreCalculatedFeeResult(FeeResult)

Pre Calculated Fee Result

Implementations

impl LowLevelDriveOperation

pub fn consume_to_fees_v0( drive_operations: Vec<LowLevelDriveOperation>, epoch: &Epoch, epochs_per_era: u16, fee_version: &FeeVersion, previous_fee_versions: Option<&CachedEpochIndexFeeVersions>, ) -> Result<Vec<FeeResult>, Error>

Returns a list of the costs of the Drive operations. Should only be used by Calculate fee

pub fn operation_cost(self) -> Result<OperationCost, Error>

Returns the cost of this operation

pub fn combine_cost_operations( operations: &[LowLevelDriveOperation], ) -> OperationCost

Filters the groveDB ops from a list of operations and puts them in a GroveDbOpBatch.

pub fn grovedb_operations_batch( insert_operations: &[LowLevelDriveOperation], ) -> GroveDbOpBatch

Filters the groveDB ops from a list of operations and puts them in a GroveDbOpBatch.

pub fn grovedb_operations_batch_consume( insert_operations: Vec<LowLevelDriveOperation>, ) -> GroveDbOpBatch

Filters the groveDB ops from a list of operations and puts them in a GroveDbOpBatch.

pub fn grovedb_operations_batch_consume_with_leftovers( insert_operations: Vec<LowLevelDriveOperation>, ) -> (GroveDbOpBatch, Vec<LowLevelDriveOperation>)

Filters the groveDB ops from a list of operations and puts them in a GroveDbOpBatch.

pub fn grovedb_operations_consume( insert_operations: Vec<LowLevelDriveOperation>, ) -> Vec<QualifiedGroveDbOp>

Filters the groveDB ops from a list of operations and collects them in a Vec<QualifiedGroveDbOp>.

pub fn for_known_path_key_empty_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty tree at the given path and key

pub fn for_known_path_key_empty_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty sum tree at the given path and key

pub fn for_known_path_key_empty_big_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty sum tree at the given path and key

pub fn for_known_path_key_empty_count_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty count tree at the given path and key

pub fn for_known_path_key_empty_count_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty count tree at the given path and key

pub fn for_known_path_key_empty_non_counted_normal_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty NormalTree wrapped in Element::NonCounted at the given path and key. The wrapper makes the inserted subtree contribute 0 to a parent count tree’s aggregate (per grovedb #654). Used by the index-walker for sibling continuations inside a range_countable value tree, so e.g. a compound byColorShape continuation under a byColor value tree (which is a CountTree) doesn’t pollute the byColor count.

pub fn for_known_path_key_empty_non_counted_tree( path: Vec<Vec<u8>>, key: Vec<u8>, tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty tree of the given tree_type wrapped in Element::NonCounted. The wrapper makes the inserted subtree contribute 0 to a parent count tree’s aggregate count (per grovedb #654), regardless of the inner tree variant.

Used by the index walker for sibling continuations inside a range_countable value tree (a CountTree). Most continuations are plain NormalTree, but in nested-range_countable cases (e.g. an index [color] is range-countable AND a deeper compound index [color, size] is also range-countable), the continuation property-name tree at "size" is itself a ProvableCountTree and must still contribute 0 to the parent <c1> CountTree.

Returns an error for tree variants whose NonCounted wrapping hasn’t been validated end-to-end yet (currently anything outside NormalTree / CountTree / ProvableCountTree).

pub fn for_known_path_key_empty_not_summed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty sum-bearing tree wrapped in Element::NotSummed (grovedb PR 670). The wrapper makes the inserted subtree contribute 0 to a parent sum tree’s running sum while still allowing any count it carries to propagate normally. Used by the index walker for continuation property-name trees inside a summable-but-not-countable value tree. For continuations under a count+sum parent, use Self::for_known_path_key_empty_not_counted_or_summed_tree.

pub fn wrap_in_non_aggregated_for_parent_tree_type( path: Vec<Vec<u8>>, key: Vec<u8>, aggregating_parent_tree_type: TreeType, inner_tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty inner tree wrapped in the wrapper variant appropriate for an aggregating_parent_tree_type.

Dispatcher around the three concrete wrapper helpers (Self::for_known_path_key_empty_non_counted_tree / Self::for_known_path_key_empty_not_summed_tree / Self::for_known_path_key_empty_not_counted_or_summed_tree) keyed on the parent’s tree type — the wrapper exists to suppress contribution to the parent’s aggregate, so the parent’s kind picks the wrapper:

• Pure count parents (CountTree / ProvableCountTree) → Element::NonCounted.
• Pure sum parents (SumTree / BigSumTree / ProvableSumTree) → Element::NotSummed.
• Combined count+sum parents (CountSumTree / ProvableCountSumTree / ProvableCountProvableSumTree) → Element::NotCountedOrSummed.
• Non-aggregating parents (NormalTree, etc.) — no wrapping needed; caller should use crate::fees::op::LowLevelDriveOperationTreeTypeConverter::empty_tree_operation_for_known_path_key directly. This dispatcher rejects them with NotSupported so an upstream bug surfaces immediately rather than silently emitting an unwrapped child that pollutes a future parent.

inner_tree_type is the tree variant being inserted under the parent — typically a property-name continuation tree (NormalTree / CountTree / ProvableCountTree / their sum-bearing siblings).

pub fn for_known_path_key_empty_not_counted_or_summed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty sum-bearing tree wrapped in Element::NotCountedOrSummed (grovedb PR 670). Suppresses BOTH count and sum propagation to the parent — used for continuation property-name trees under a count+sum aggregating value tree (CountSumTree / ProvableCountSumTree / ProvableCountProvableSumTree). Same accepted inner-type set as Self::for_known_path_key_empty_not_summed_tree.

pub fn for_known_path_key_empty_tree_contributing_zero_to_parent( path: Vec<Vec<u8>>, key: Vec<u8>, aggregating_parent_tree_type: TreeType, inner_tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty continuation tree under an aggregating parent so it contributes zero to every axis the parent aggregates — the v2 index walkers’ replacement for Self::wrap_in_non_aggregated_for_parent_tree_type.

The v0 dispatcher above covers only the diagonal of the parent×inner matrix (count parent + count-ish inner, sum parent + sum-bearing inner, count+sum parent + sum-bearing inner) and errors on everything else, which made shared-prefix aggregate contracts (e.g. a summable [a] next to a plain compound [a, b]) reject every document insert. This dispatcher completes the matrix using only combinations grovedb accepts:

• CountTree parent → Element::NonCounted(inner) for any inner tree variant (a NonCounted child contributes 0 to the count; the parent has no sum axis).
• CountSumTree parent → sum-bearing inner: Element::NotCountedOrSummed(inner); non-sum inner: Element::NonCounted(inner) (count suppressed by the wrapper, sum contribution of a non-sum inner is 0 by definition — sum_value_or_default() returns 0 for it).
• SumTree / BigSumTree / ProvableSumTree parent → sum-bearing inner: Element::NotSummed(inner); non-sum inner: no wrapper at all — a non-sum child already contributes 0 to a sum-only parent, and grovedb has no NotSummed(non-sum) form.
• Provable count-bearing parents (ProvableCountTree / ProvableCountSumTree / ProvableCountProvableSumTree) → NotSupported. These commit their count into every node hash and reject count-suppressed children at grovedb’s insert guards (TreeType::accepts_non_counted_children / accepts_not_counted_or_summed_children), so callers must demote the parent first — see crate::drive::document::index_level_tree_types.
• Non-aggregating parents → NotSupported; use crate::fees::op::LowLevelDriveOperationTreeTypeConverter::empty_tree_operation_for_known_path_key directly.

Only reachable from the v2 index walkers (platform-version gated); the v0 dispatcher stays byte-identical for the frozen v0/v1 walkers.

pub fn for_known_path_key_empty_non_counted_any_tree( path: Vec<Vec<u8>>, key: Vec<u8>, tree_type: TreeType, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty tree of any of the nine standard merk tree variants wrapped in Element::NonCounted. Extends Self::for_known_path_key_empty_non_counted_tree’s accepted set (NormalTree / CountTree / ProvableCountTree) with the six sum-bearing variants: Element::new_non_counted accepts any non-wrapper inner, and under the only parents the v2 walkers use it for (CountTree, CountSumTree — both without per-node count commitments) the wrapper suppresses the count contribution while a sum-bearing inner’s sum still propagates on the parent’s sum axis if it has one — which is exactly the v0-diagonal behavior for count-only parents, and unreachable for CountSumTree parents (the zero-contribution dispatcher routes their sum-bearing inners through NotCountedOrSummed instead).

Kept separate from the frozen v0 helper so pre-v14 consensus behavior stays byte-identical.

pub fn for_known_path_key_empty_provable_count_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable count tree at the given path and key

pub fn for_known_path_key_empty_provable_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable sum tree at the given path and key. The provable variant commits aggregated sub-sums to every internal merk node, enabling O(log n) AggregateSumOnRange proofs over range queries on the property whose values feed the tree.

Used by the index walker for property-name trees of indexes that declare rangeSummable: true (mirrors the count-side Self::for_known_path_key_empty_provable_count_tree).

pub fn for_known_path_key_empty_provable_count_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable count-sum tree at the given path and key. Pre-PR-670 variant: per-node counts committed to every internal merk node, but the sum is only carried at the root (not per-node). Use this when an index declares rangeCountable: true plus non-range summable: "<prop>" — count queries get the AggregateCountOnRange benefit while sum queries return only the root total.

pub fn for_known_path_key_empty_provable_count_provable_sum_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable-count-provable-sum tree (PCPS) at the given path and key. The grovedb PR 670 newcomer: both per-node counts AND per-node sums committed to every internal merk node, so a single tree can answer both AggregateCountOnRange, AggregateSumOnRange, AND the new AggregateCountAndSumOnRange (combined) range queries.

Used by the index walker for property-name trees of indexes that declare BOTH rangeCountable: true AND rangeSummable: true, and for primary-key trees that declare both at the doctype level. The dispatch table in crate::drive::document::primary_key_tree_type’s v1 arm picks TreeType::ProvableCountProvableSumTree for these cases.

pub fn for_estimated_path_key_empty_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty tree at the given path and key

pub fn for_estimated_path_key_empty_sum_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty sum tree at the given path and key

pub fn for_estimated_path_key_empty_count_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty count tree at the given (estimated) path and key

pub fn for_estimated_path_key_empty_provable_count_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable count tree at the given (estimated) path and key

pub fn for_estimated_path_key_empty_provable_sum_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_provable_sum_tree. See its doc.

pub fn for_estimated_path_key_empty_count_sum_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_count_sum_tree. See its doc.

pub fn for_estimated_path_key_empty_provable_count_sum_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_provable_count_sum_tree. See its doc.

pub fn for_estimated_path_key_empty_provable_count_provable_sum_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_provable_count_provable_sum_tree. See its doc.

pub fn for_known_path_key_empty_provable_count_indexed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sets GroveOperation for inserting an empty provable count-indexed tree (PCIT, grovedb PR 657) at the given path and key. The primary Merk is a byte-compatible mirror of ProvableCountTree, so every existing AggregateCountOnRange read keeps working against it; what the indexed variant adds is one ordered secondary Merk keyed by (count_be ‖ child_key), which is what makes “top / bottom K groups by document count” O(log n + k) with a proof.

Used at contract registration (and by the index walkers when a deeper level is materialized lazily) for an index that declares rankedCountable: true while its range layout is count-only. An index that also declares rangeSummable lays out as PCPS underneath and therefore takes the multi-axis Self::for_known_path_key_empty_provable_count_provable_sum_indexed_tree path instead, even when Count is its only ranking axis.

pub fn for_known_path_key_empty_provable_sum_indexed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, storage_flags: Option<&StorageFlags>, ) -> Self

Sum-axis counterpart of Self::for_known_path_key_empty_provable_count_indexed_tree: an empty provable sum-indexed tree (PSIT) whose primary mirrors ProvableSumTree and whose single secondary is keyed by (sum_sortable_be ‖ child_key).

pub fn for_known_path_key_empty_provable_count_provable_sum_indexed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, ranked_axes: Vec<(u8, Option<Vec<u8>>)>, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Sets GroveOperation for inserting an empty provable count + provable sum indexed tree (PCPSIT, grovedb PR 657) at the given path and key, carrying ranked_axes — the canonical (axis_tag, secondary_root_key) TLV, sorted ascending by tag with no duplicates and 1..=3 entries. Every secondary starts empty, so each root key is None.

Unlike the two single-axis helpers this one returns a Result: the axes list is caller-supplied and grovedb validates it (Element::validate_pcpsit_axes), because an out-of-order, duplicated or empty TLV would still be hashed into the parent via axes_digest and produce a tree whose secondaries nothing can address.

pub fn for_known_path_key_empty_indexed_tree( path: Vec<Vec<u8>>, key: Vec<u8>, tree_type: TreeType, ranked_axes: &[IndexAxis], storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Dispatcher over the three indexed-tree constructors, keyed on the resolved tree_type and the ranking axes that produced it (see [crate::drive::document::ranked_index_tree_type]).

ranked_axes must be non-empty and canonical; the single-axis variants additionally require that the axis matches the variant, since their element shape hard-codes which aggregate the one secondary is keyed by. Any other combination is an upstream resolution bug and is rejected rather than silently narrowed.

pub fn for_estimated_path_key_empty_provable_count_indexed_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_provable_count_indexed_tree.

pub fn for_estimated_path_key_empty_provable_sum_indexed_tree( path: KeyInfoPath, key: KeyInfo, storage_flags: Option<&StorageFlags>, ) -> Self

Cost-estimation analog of Self::for_known_path_key_empty_provable_sum_indexed_tree.

pub fn for_estimated_path_key_empty_provable_count_provable_sum_indexed_tree( path: KeyInfoPath, key: KeyInfo, ranked_axes: Vec<(u8, Option<Vec<u8>>)>, storage_flags: Option<&StorageFlags>, ) -> Result<Self, Error>

Cost-estimation analog of Self::for_known_path_key_empty_provable_count_provable_sum_indexed_tree.

pub fn insert_for_known_path_key_element( path: Vec<Vec<u8>>, key: Vec<u8>, element: Element, ) -> Self

Sets GroveOperation for inserting an element at the given path and key

pub fn replace_for_known_path_key_element( path: Vec<Vec<u8>>, key: Vec<u8>, element: Element, ) -> Self

Sets GroveOperation for replacement of an element at the given path and key

pub fn patch_for_known_path_key_element( path: Vec<Vec<u8>>, key: Vec<u8>, element: Element, change_in_bytes: i32, ) -> Self

Sets GroveOperation for patching of an element at the given path and key This is different from replacement which does not add or delete bytes

pub fn insert_for_estimated_path_key_element( path: KeyInfoPath, key: KeyInfo, element: Element, ) -> Self

Sets GroveOperation for inserting an element at an unknown estimated path and key

pub fn replace_for_estimated_path_key_element( path: KeyInfoPath, key: KeyInfo, element: Element, ) -> Self

Sets GroveOperation for replacement of an element at an unknown estimated path and key

pub fn refresh_reference_for_known_path_key_reference_info( path: Vec<Vec<u8>>, key: Vec<u8>, reference_path_type: ReferencePathType, max_reference_hop: MaxReferenceHop, flags: Option<ElementFlags>, trust_refresh_reference: bool, ) -> Self

Sets GroveOperation for refresh of a reference at the given path and key

pub fn refresh_reference_with_sum_item_for_known_path_key_reference_info( path: Vec<Vec<u8>>, key: Vec<u8>, reference_path_type: ReferencePathType, max_reference_hop: MaxReferenceHop, sum_value: i64, flags: Option<ElementFlags>, trust_refresh_reference: bool, ) -> Self

Sets GroveOperation for refresh of a grovedb::Element::ReferenceWithSumItem at the given path and key, overriding the carried sum with sum_value.

Used by document-update paths on summable indexes: when the summed property’s value changes but the index keys do not, the reference body stays the same but its sum contribution must be rewritten so ancestor SumTree / ProvableCountSumTree / ProvableCountProvableSumTree aggregates pick up the delta.

Mirrors Self::refresh_reference_for_known_path_key_reference_info but emits a grovedb RefreshReference op in SumItemReference* mode instead of PlainReference* mode.

Trait Implementations

impl Debug for LowLevelDriveOperation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LowLevelDriveOperation

impl PartialEq for LowLevelDriveOperation

fn eq(&self, other: &LowLevelDriveOperation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LowLevelDriveOperation