Enum BatchTransitionAction 

pub enum BatchTransitionAction {
    V0(BatchTransitionActionV0),
}

documents batch transition action

Variants

V0(BatchTransitionActionV0)

v0

Implementations

impl BatchTransitionAction

pub fn owner_id(&self) -> Identifier

owner id

pub fn transitions(&self) -> &Vec<BatchedTransitionAction>

transitions

pub fn transitions_mut(&mut self) -> &mut Vec<BatchedTransitionAction>

transitions

pub fn transitions_take(&mut self) -> Vec<BatchedTransitionAction>

transitions

pub fn transitions_owned(self) -> Vec<BatchedTransitionAction>

transitions owned

pub fn set_transitions(&mut self, transitions: Vec<BatchedTransitionAction>)

set transitions

pub fn user_fee_increase(&self) -> UserFeeIncrease

fee multiplier

pub fn contract_group_memberships( &self, contract_id: &Identifier, ) -> Option<&ResolvedContractGroupMemberships>

The group memberships the transformer resolved for a contract the batch touches

pub fn set_contract_group_memberships( &mut self, contract_id: Identifier, resolved: ResolvedContractGroupMemberships, )

Records the group memberships of a contract the batch touches

pub fn lapsed_suspensions(&self) -> &BTreeSet<Identifier>

The contracts on which the batch sweeps its owner’s lapsed suspension when it executes

pub fn moderators_pot_settlements(&self) -> &[ModeratorsPotSettlement]

The settles of moderators pots the batch forces before it changes a seated team

pub fn take_moderators_pot_settlements( &mut self, ) -> Vec<ModeratorsPotSettlement>

Takes the settles of moderators pots out of the batch, for its conversion to operations

pub fn set_moderators_pot_settlements( &mut self, settlements: Vec<ModeratorsPotSettlement>, )

Records the settles of moderators pots the batch forces before it changes a seated team

impl BatchTransitionAction

pub fn all_used_balances(&self) -> Result<Option<Credits>, ProtocolError>

The sum of all purchases amount and all conflicting index collateral voting funds

pub fn gas_sponsor(&self) -> Option<&ResolvedGasSponsor>

The contract owner the batch transformer resolved as the gas sponsor, if any

pub fn declared_action_fees( &self, ) -> Vec<(Identifier, Identifier, ActionFeePricing, DocumentActionFee)>

The fee each document transition of the batch owes for its action, before the fee multiplier, with the contract it goes to, that contract’s owner, and how it is priced: what its document type declares, with the moderators part it agreed to when that is a discount the contract’s seated moderation charter gives (advanced structure validation refuses any other). A transition that became a nonce bump declares nothing: only an action that executes is charged.

pub fn contracts_with_moderators_discounts(&self) -> BTreeSet<Identifier>

The elected contracts on whose moderated document types some document transition of the batch agrees to a discounted moderators part (protocol version 14): the contracts whose seated moderation charter the batch transformer reads the moderators share of.

pub fn set_seated_moderators_share( &mut self, contract_id: Identifier, share: Option<u8>, )

Records the moderators share of the seated moderation charter of contract_id, None when no charter is seated on it

pub fn action_fee_multiplier_permille(&self) -> Option<FeeMultiplier>

The fee multiplier, in permille, of the epoch the batch executes in, as the batch transformer read it (protocol version 14). Only read when some document transition of the batch declares an action fee priced by it.

pub fn set_action_fee_multiplier_permille( &mut self, multiplier: Option<FeeMultiplier>, )

Records the fee multiplier of the epoch the batch executes in

pub fn resolved_action_fees( &self, ) -> Result<Vec<ResolvedDocumentActionFee>, ProtocolError>

The action fees the batch owes: what its document transitions declare, priced.

They are read off the transitions as they are now, not as the transformer built them. State validation replaces a transition that fails with a nonce bump after the transformer ran, and a bump declares nothing, so a fee is only ever owed for an action that executes.

pub fn validate_action_fee_agreements( &self, ) -> Result<Result<(), ConsensusError>, ProtocolError>

Whether every document transition that owes an action fee agreed to it: the transition names the amounts and the pricing its document type declares, or, on a document type an elected contract moderates, the declared owner part and pricing with the share of the declared moderators part the contract’s seated moderation charter takes; and, for a fee priced by the fee multiplier, accepts the multiplier of the epoch the batch executes in. The inner error is the consensus error of the first transition that did not. Everything it is judged against travels on the action (the charter’s share as the transformer read it), so this reads no state.

pub fn set_gas_sponsor(&mut self, gas_sponsor: Option<ResolvedGasSponsor>)

Records the contract owner who sponsors the batch’s gas, with their balance

pub fn resolve_gas_payer(&self) -> Result<GasPayer, ConsensusError>

Who pays the gas of the batch, or the consensus error explaining why the batch’s requests cannot be honoured: a transition asking for more than its document type’s token cost offers, or a batch whose transitions do not all name the same payer.

pub fn all_purchases_amount(&self) -> Result<Option<Credits>, ProtocolError>

The sum of all purchases amounts for all purchase transitions in the batch

pub fn all_conflicting_index_collateral_voting_funds( &self, ) -> Result<Option<Credits>, ProtocolError>

The sum of all conflicting index collateral voting funds for all document create transitions in the batch

pub fn combined_security_level_requirement( &self, ) -> Result<Vec<SecurityLevel>, ProtocolError>

Determines the security level requirements for the batch transition action.

This method performs the following steps:

1. Retrieves all document types associated with the state transitions (STs) in the batch.
2. For each document type, fetches its schema to determine its security level requirement.
   • If the schema specifies a security level, that is used.
   • Otherwise, a default security level is used.

The method then determines the highest security level (which corresponds to the lowest integer value of the SecurityLevel enum) across all documents affected by the state transitions. This highest level becomes the signature requirement for the entire batch transition action.

Returns

• Returns a Result containing a Vec<SecurityLevel> which is the list of security levels required for the batch transition action.
• Returns an Err of type ProtocolError if any error occurs during the process.

Examples

// Assuming `batch_transition_action` is an instance of `DocumentsBatchTransitionAction`
let required_levels = batch_transition_action.contract_based_security_level_requirement()?;

Trait Implementations

impl Clone for BatchTransitionAction

fn clone(&self) -> BatchTransitionAction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchTransitionAction

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

Formats the value using the given formatter.

impl DriveHighLevelOperationConverter for BatchTransitionAction

fn into_high_level_drive_operations<'b>( self, epoch: &Epoch, platform_version: &PlatformVersion, ) -> Result<Vec<DriveOperation<'b>>, Error>

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

impl From<BatchTransitionAction> for StateTransitionAction

fn from(value: BatchTransitionAction) -> Self

Converts to this type from the input type.

impl From<BatchTransitionActionV0> for BatchTransitionAction

fn from(value: BatchTransitionActionV0) -> Self

Converts to this type from the input type.