Enum DriveOperation 

pub enum DriveOperation<'a> {
    DataContractOperation(DataContractOperationType<'a>),
    DocumentOperation(DocumentOperationType<'a>),
    TokenOperation(TokenOperationType),
    WithdrawalOperation(WithdrawalOperationType),
    IdentityOperation(IdentityOperationType),
    PrefundedSpecializedBalanceOperation(PrefundedSpecializedBalanceOperationType),
    SystemOperation(SystemOperationType),
    GroupOperation(GroupOperationType),
    ContractGroupOperation(ContractGroupOperationType),
    ContractModerationOperation(ContractModerationOperationType),
    ContractFeePotOperation(ContractFeePotOperationType),
    AddressFundsOperation(AddressFundsOperationType),
    ShieldedPoolOperation(ShieldedPoolOperationType),
    GroveDBOperation(QualifiedGroveDbOp),
    GroveDBOpBatch(GroveDbOpBatch),
    FinalizeOperation(DriveOperationFinalizeTask),
}

All types of Drive Operations

Variants

DataContractOperation(DataContractOperationType<'a>)

A contract operation

DocumentOperation(DocumentOperationType<'a>)

A document operation

TokenOperation(TokenOperationType)

A token operation

WithdrawalOperation(WithdrawalOperationType)

Withdrawal operation

IdentityOperation(IdentityOperationType)

An identity operation

PrefundedSpecializedBalanceOperation(PrefundedSpecializedBalanceOperationType)

An operation on prefunded balances

SystemOperation(SystemOperationType)

A system operation

GroupOperation(GroupOperationType)

A group operation

ContractGroupOperation(ContractGroupOperationType)

A contract group operation

ContractModerationOperation(ContractModerationOperationType)

A contract moderation operation: an entry of a banlist or a suspension list

ContractFeePotOperation(ContractFeePotOperationType)

A contract fee pot operation: credits of a contract’s document action fees

AddressFundsOperation(AddressFundsOperationType)

An address funds operation

ShieldedPoolOperation(ShieldedPoolOperationType)

A shielded pool operation

GroveDBOperation(QualifiedGroveDbOp)

A single low level groveDB operation

GroveDBOpBatch(GroveDbOpBatch)

Multiple low level groveDB operations

FinalizeOperation(DriveOperationFinalizeTask)

An operation that only produces finalization tasks (no low-level ops)

Implementations

impl DriveOperation<'_>

pub fn forfeits_storage_refunds(&self) -> bool

Whether the batch this operation is in refunds nobody for the storage its document operations remove: see ContractModerationOperationType::ForfeitStorageRefunds.

pub fn refunds_moderation_storage(&self) -> bool

Whether this operation frees moderation storage its payer is owed a refund of: the replacement of a removal record (a restored one, by a fresh deletion), which may leave it shorter, the approval that closes a team action, which moves the approvals given before it and the action’s info to the closed actions, and an approval that deletes the approvals of members who left the team. A batch forfeiting its refunds then keeps its document operations apart (Drive::apply_drive_operations generation 1).

impl DriveOperation<'_>

pub fn credit_mints(operations: &[DriveOperation<'_>]) -> Credits

Sums the credits the batch mints into Platform (its AddToSystemCredits operations, saturating). This is the gross inflow of the batch — the net rule of the daily withdrawal limit records it per block, and netting against removals here instead would let a same-block deposit and withdrawal hide the inflow.

pub fn merge_balance_writes(operations: Vec<Self>) -> Result<Vec<Self>, Error>

Merges every write of one identity balance, of one contract fee pot, and of one prefunded specialized balance, into a single net operation.

Each of these operations computes the new value from the one committed before its batch, and GroveDB keeps only the last write of a key, so two of them in one batch lose the first: a purchase price and a purchase fee leaving the buyer, a contested document’s voting fund and its creation fee, a sale and the action fee of a contract owner who sponsors the gas. Merged, they apply as if in turn. The merged operation takes the place of the first one on its key, and a balance or pot the writes leave as it was gets none. A key written once keeps its operation untouched.

Two other kinds of write compute from the committed value too and are not merged here, because no batch repeats their keys: the total system credits (SystemOperationType) and address balances (AddressFundsOperationType). Their docs say what keeps it so; a change that could repeat one must extend this merge first.

pub fn refuse_repeated_token_balance_writes( operations: &[Self], ) -> Result<(), Error>

Refuses a batch whose token operations write one identity’s balance of a token, one token’s total supply, or the total one token’s shielded pool holds, more than once.

These writes compute the new value from the one committed before the batch too, but a transfer writes two balances, a mint or a burn a balance and the supply, and a shield or an unshield a balance and the pool total, so they cannot be merged into operations of their own kinds. No state transition makes two of them on one key: a batch carries one transition, and each writes a key at most once. A batch that did would lose all but the last write, so it is refused instead.

Trait Implementations

impl<'a> Clone for DriveOperation<'a>

fn clone(&self) -> DriveOperation<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for DriveOperation<'a>

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

Formats the value using the given formatter.

impl DriveLowLevelOperationConverter for DriveOperation<'_>

fn into_low_level_drive_operations( self, drive: &Drive, estimated_costs_only_with_layer_info: &mut Option<HashMap<KeyInfoPath, EstimatedLayerInformation>>, block_info: &BlockInfo, transaction: TransactionArg<'_, '_>, platform_version: &PlatformVersion, ) -> Result<Vec<LowLevelDriveOperation>, Error>

This will get a list of atomic drive operations from a high level operations