Enum LowLevelDriveOperation 

pub enum LowLevelDriveOperation {
    GroveOperation(QualifiedGroveDbOp),
    EphemeralGroveOperation(QualifiedGroveDbOp, EphemeralPricing),
    FunctionOperation(FunctionOp),
    CalculatedCostOperation(OperationCost),
    CalculatedEphemeralCostOperation(OperationCost, EphemeralPricing),
    PreCalculatedFeeResult(FeeResult),
    RepaidIdentityDebt(Credits),
}

Drive operation

Variants

GroveOperation(QualifiedGroveDbOp)

Grove operation

EphemeralGroveOperation(QualifiedGroveDbOp, EphemeralPricing)

A grove operation writing bytes that provably live a bounded time, applied in its own batch (one per EphemeralPricing) so its added bytes can be priced by that rule instead of at the perpetual storage price. The elements it writes carry no storage flags (the retag that produces it strips them), so their removal refunds nothing. Produced for sub-levels of a timeRange index that declares a ttl (EphemeralPricing::TimeRangeTtl) and for the writes of a document whose type declares a ttl (EphemeralPricing::DocumentTtl); both keywords are unreachable before protocol v14, where their grammar does not parse.

FunctionOperation(FunctionOp)

A drive operation

CalculatedCostOperation(OperationCost)

Calculated cost operation

CalculatedEphemeralCostOperation(OperationCost, EphemeralPricing)

The applied cost of an ephemeral batch — same pricing rule as the Self::EphemeralGroveOperations it applied, carrying the cost the batch application (or its estimation) actually returned.

PreCalculatedFeeResult(FeeResult)

Pre Calculated Fee Result

RepaidIdentityDebt(Credits)

Credits an identity’s incoming balance repaid of its debt (its negative credit balance). Not a GroveDB operation and no cost: the debt stood for processing fees the identity could not pay, which never reached a fee pool, so whoever applies the batch owes these credits to the current epoch’s processing fee pool. Leaving them out would take them out of every balance the credit sum counts. Produced from protocol version 14 only, by add_to_identity_balance_operations 1; an apply that meets one it does not route fails instead of dropping it.

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 take_repaid_identity_debt( operations: &mut Vec<LowLevelDriveOperation>, ) -> Result<Credits, Error>

Removes every RepaidIdentityDebt from operations and returns their total: the credits the caller owes the current epoch’s processing fee pool for the batch.

pub fn holds_repaid_identity_debt(operations: &[LowLevelDriveOperation]) -> bool

Whether operations holds a RepaidIdentityDebt, which an apply must route before it applies the rest.

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.

Every other operation is dropped, a RepaidIdentityDebt included: its credits are owed to a fee pool, so operations that may hold one (identity credits from protocol version 14) must go through Self::take_repaid_identity_debt or an apply that routes it first.

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

Filters the ordinary groveDB ops from a list of operations into a GroveDbOpBatch, returning everything else — ephemeral (TTL’d subtree) grove operations included — as leftovers, so no caller can lose them or bill them at the ordinary storage price by accident. The apply path splits three ways instead (grovedb_operations_batch_consume_split_ephemeral).

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

Splits operations three ways: the ordinary grove batch, one ephemeral grove batch per EphemeralPricing — each applied separately so its cost can be consumed under its own rule — and every non-grove leftover. The ephemeral batches come in the order they must apply in (a document’s own writes before timeRange TTL sub-levels, then first appearance), and each keeps its operations in their original order.

pub fn retag_ephemeral(self) -> LowLevelDriveOperation

Re-tag an operation as targeting a TTL’d timeRange index subtree (EphemeralPricing::TimeRangeTtl); see Self::retag_ephemeral_with.

pub fn retag_document_ttl( self, pricing: EphemeralPricing, ) -> LowLevelDriveOperation

Re-tag one of the writes of a document whose type declares a ttl, so its bytes are priced for the document’s remaining lifetime. Only ordinary grove operations move: an operation already ephemeral (a timeRange TTL sub-level) keeps its own rule, and costs and fee results pass through untouched.

pub fn retag_ephemeral_with( self, pricing: EphemeralPricing, ) -> LowLevelDriveOperation

Re-tag an operation as ephemeral under pricing, so its bytes are consumed by that rule. Grove operations move to that rule’s batch, their elements stripped of storage flags; already-calculated costs keep their numbers under the rule; everything else, operations already ephemeral included, passes through untouched.

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>.

Every other operation is dropped, a RepaidIdentityDebt included, so operations that may hold one must have it routed first (see Self::grovedb_operations_batch_consume).

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LowLevelDriveOperation