Struct TransactionEffectsV1 

pub struct TransactionEffectsV1 {
    pub status: ExecutionStatus,
    pub epoch: u64,
    pub gas_cost_summary: GasCostSummary,
    pub transaction_digest: Digest,
    pub gas_object_index: Option<u32>,
    pub events_digest: Option<Digest>,
    pub dependencies: Vec<Digest>,
    pub lamport_version: Version,
    pub changed_objects: Vec<ChangedObject>,
    pub unchanged_shared_objects: Vec<UnchangedSharedObject>,
    pub auxiliary_data_digest: Option<Digest>,
}

Version 1 of TransactionEffects

BCS

The BCS serialized form for this type is defined by the following ABNF:

transaction-effects-v1 = execution-status                   ; status
                         u64                                ; epoch
                         gas-cost-summary                   ; gas-used
                         digest                             ; transaction-digest
                         (option u32)                       ; gas-object-index
                         (option digest)                    ; events-digest
                         (vector digest)                    ; dependencies
                         u64                                ; lamport-version
                         (vector changed-object)            ; changed-objects
                         (vector unchanged-shared-object)   ; unchanged-shared-objects
                         (option digest)                    ; auxiliary-data-digest

Fields

status: ExecutionStatus

The status of the execution

epoch: u64

The epoch when this transaction was executed.

gas_cost_summary: GasCostSummary

The gas used by this transaction

transaction_digest: Digest

The transaction digest

gas_object_index: Option<u32>

The updated gas object reference, as an index into the changed_objects vector. Having a dedicated field for convenient access. System transaction that don’t require gas will leave this as None.

events_digest: Option<Digest>

The digest of the events emitted during execution, can be None if the transaction does not emit any event.

dependencies: Vec<Digest>

The set of transaction digests this transaction depends on.

lamport_version: Version

The version number of all the written Move objects by this transaction.

changed_objects: Vec<ChangedObject>

Objects whose state are changed in the object store.

unchanged_shared_objects: Vec<UnchangedSharedObject>

Shared objects that are not mutated in this transaction. Unlike owned objects, read-only shared objects’ version are not committed in the transaction, and in order for a node to catch up and execute it without consensus sequencing, the version needs to be committed in the effects.

auxiliary_data_digest: Option<Digest>

Auxiliary data that are not protocol-critical, generated as part of the effects but are stored separately. Storing it separately allows us to avoid bloating the effects with data that are not critical. It also provides more flexibility on the format and type of the data.

Trait Implementations

impl Arbitrary for TransactionEffectsV1

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<TransactionEffectsV1>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( args_shared: <TransactionEffectsV1 as Arbitrary>::Parameters, ) -> <TransactionEffectsV1 as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for TransactionEffectsV1

fn clone(&self) -> TransactionEffectsV1

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionEffectsV1

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionEffectsV1

fn deserialize<D>( deserializer: D, ) -> Result<TransactionEffectsV1, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TransactionEffectsV1

fn eq(&self, other: &TransactionEffectsV1) -> 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 Serialize for TransactionEffectsV1

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TransactionEffectsAPI for TransactionEffectsV1

fn status(&self) -> &ExecutionStatus

Return the status of the transaction.

fn into_status(self) -> ExecutionStatus

Consume self and return the owned status of the transaction.

fn epoch(&self) -> EpochId

Return the epoch in which this transaction was executed.

fn modified_at_versions(&self) -> Vec<(ObjectId, Version)>

Return the (ObjectId, Version) pair, at their pre-execution version, of every object that existed in the store before this transaction and was modified by it (mutated, wrapped, or deleted).

fn lamport_version(&self) -> Version

The version assigned to all output objects (apart from packages).

fn old_object_metadata(&self) -> Vec<(ObjectRef, Owner)>

Metadata of objects prior to modification. This includes any object that exists in the store prior to this transaction and is modified in this transaction. It includes objects that are mutated, wrapped and deleted.

fn input_shared_objects(&self) -> Vec<InputSharedObject>

Returns the list of sequenced shared objects used in the input. This is needed in effects because in transaction we only have object ID for shared objects. Their version and digest can only be figured out after sequencing. Also provides the use kind to indicate whether the object was mutated or read-only. It does not include per epoch config objects since they do not require sequencing. TODO: Rename this function to indicate sequencing requirement.

fn created(&self) -> Vec<(ObjectRef, Owner)>

Objects (Move objects and packages) newly created by this transaction, paired with their owner. Excludes objects that were created and then wrapped within the same transaction.

fn mutated(&self) -> Vec<(ObjectRef, Owner)>

Objects that existed before this transaction and whose contents were updated by it (in-place mutations and system package upgrades), reported at their post-execution (ObjectRef, Owner).

fn unwrapped(&self) -> Vec<(ObjectRef, Owner)>

Objects that were wrapped inside another object before this transaction and have been promoted back to top-level objects in the store by it.

fn deleted(&self) -> Vec<ObjectRef>

Objects that existed before this transaction and were deleted by it. References use the post-execution version and the TransactionEffectsDigest::OBJECT_DELETED tombstone digest.

fn unwrapped_then_deleted(&self) -> Vec<ObjectRef>

Objects that were unwrapped and then deleted within this same transaction (i.e. did not exist as top-level objects either before or after). References use the post-execution version and the TransactionEffectsDigest::OBJECT_DELETED tombstone digest.

fn wrapped(&self) -> Vec<ObjectRef>

Objects that existed as top-level objects before this transaction and have been wrapped inside another object by it (i.e. no longer visible in the object store as top-level). References use the post-execution version and the TransactionEffectsDigest::OBJECT_WRAPPED tombstone digest.

fn object_changes(&self) -> Vec<ObjectChange>

Returns a flattened view of every object change recorded in these effects: for each touched object, the input and output version/digest (when present) together with the IDOperation describing whether the ID was created, deleted, or unchanged.

fn gas_object(&self) -> (ObjectRef, Owner)

Returns the post-execution reference and owner of the gas object.

fn events_digest(&self) -> Option<&TransactionEventsDigest>

Digest of the events emitted by this transaction, or None if it emitted no events.

fn dependencies(&self) -> &[TransactionDigest]

Digests of the transactions this one depends on, i.e. transactions that must be executed before this one for its inputs to be available.

fn transaction_digest(&self) -> &TransactionDigest

Digest of the transaction that produced these effects.

fn gas_cost_summary(&self) -> &GasCostSummary

Return the gas cost summary of the transaction.

fn unchanged_shared_objects(&self) -> Vec<(ObjectId, UnchangedSharedKind)>

Returns all root shared objects (i.e. not child object) that are read-only in the transaction.

fn deleted_mutably_accessed_shared_objects(&self) -> Vec<ObjectId>

IDs of shared objects that were declared as mutable inputs by the transaction but had already been deleted at the time of execution.

impl TransactionEffectsAPIForTesting for TransactionEffectsV1

fn status_mut_for_testing(&mut self) -> &mut ExecutionStatus

Returns a mutable reference to the execution status, for tests.

fn gas_cost_summary_mut_for_testing(&mut self) -> &mut GasCostSummary

Returns a mutable reference to the gas cost summary, for tests.

fn transaction_digest_mut_for_testing(&mut self) -> &mut TransactionDigest

Returns a mutable reference to the transaction digest, for tests.

fn dependencies_mut_for_testing(&mut self) -> &mut Vec<TransactionDigest>

Returns a mutable reference to the dependency list, for tests.

fn unsafe_add_input_shared_object_for_testing( &mut self, kind: InputSharedObject, )

Records kind as an input shared object without validating that it is consistent with the rest of the effects. For tests only.

fn unsafe_add_deleted_live_object_for_testing(&mut self, object_ref: ObjectRef)

Records an entry that represents the pre-execution version of a still live object, without validating consistency with the rest of the effects. For tests only.

fn unsafe_add_object_tombstone_for_testing(&mut self, object_ref: ObjectRef)

Records a tombstone entry for a deleted object, without validating consistency with the rest of the effects. For tests only.

impl Eq for TransactionEffectsV1

impl StructuralPartialEq for TransactionEffectsV1