Enum TransactionKind 

#[non_exhaustive]
pub enum TransactionKind {
    ProgrammableTransaction(ProgrammableTransaction),
    ChangeEpoch(ChangeEpoch),
    Genesis(GenesisTransaction),
    ConsensusCommitPrologue(ConsensusCommitPrologue),
    AuthenticatorStateUpdate(AuthenticatorStateUpdate),
    EndOfEpoch(Vec<EndOfEpochTransactionKind>),
    RandomnessStateUpdate(RandomnessStateUpdate),
    ConsensusCommitPrologueV2(ConsensusCommitPrologueV2),
    ConsensusCommitPrologueV3(ConsensusCommitPrologueV3),
    ConsensusCommitPrologueV4(ConsensusCommitPrologueV4),
}

Transaction type

BCS

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

transaction-kind    =  %x00 ptb
                    =/ %x01 change-epoch
                    =/ %x02 genesis-transaction
                    =/ %x03 consensus-commit-prologue
                    =/ %x04 authenticator-state-update
                    =/ %x05 (vector end-of-epoch-transaction-kind)
                    =/ %x06 randomness-state-update
                    =/ %x07 consensus-commit-prologue-v2
                    =/ %x08 consensus-commit-prologue-v3
                    =/ %x09 consensus-commit-prologue-v4
                    =/ %x0A ptb

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ProgrammableTransaction(ProgrammableTransaction)

A user transaction comprised of a list of native commands and move calls

ChangeEpoch(ChangeEpoch)

System transaction used to end an epoch.

The ChangeEpoch variant is now deprecated (but the ChangeEpoch struct is still used by EndOfEpochTransaction below).

Genesis(GenesisTransaction)

Transaction used to initialize the chain state.

Only valid if in the genesis checkpoint (0) and if this is the very first transaction ever executed on the chain.

ConsensusCommitPrologue(ConsensusCommitPrologue)

V1 consensus commit update

AuthenticatorStateUpdate(AuthenticatorStateUpdate)

Update set of valid JWKs used for zklogin

EndOfEpoch(Vec<EndOfEpochTransactionKind>)

Set of operations to run at the end of the epoch to close out the current epoch and start the next one.

RandomnessStateUpdate(RandomnessStateUpdate)

Randomness update

ConsensusCommitPrologueV2(ConsensusCommitPrologueV2)

V2 consensus commit update

ConsensusCommitPrologueV3(ConsensusCommitPrologueV3)

V3 consensus commit update

ConsensusCommitPrologueV4(ConsensusCommitPrologueV4)

V4 consensus commit update

Trait Implementations

impl Arbitrary for TransactionKind

type Parameters = ()

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

type Strategy = BoxedStrategy<TransactionKind>

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

fn arbitrary_with(args: <Self as Arbitrary>::Parameters) -> Self::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 TransactionKind

fn clone(&self) -> TransactionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TransactionKind

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TransactionKind

impl StructuralPartialEq for TransactionKind