Enum diem_types::transaction::Transaction

pub enum Transaction {
    UserTransaction(SignedTransaction),
    GenesisTransaction(WriteSetPayload),
    BlockMetadata(BlockMetadata),
    StateCheckpoint,
}

Transaction will be the transaction type used internally in the diem node to represent the transaction to be processed and persisted.

We suppress the clippy warning here as we would expect most of the transaction to be user transaction.

Variants

UserTransaction(SignedTransaction)

Transaction submitted by the user. e.g: P2P payment transaction, publishing module transaction, etc. TODO: We need to rename SignedTransaction to SignedUserTransaction, as well as all the other transaction types we had in our codebase.

Tuple Fields of UserTransaction

0: SignedTransaction

GenesisTransaction(WriteSetPayload)

Transaction that applies a WriteSet to the current storage, it’s applied manually via db-bootstrapper.

Tuple Fields of GenesisTransaction

0: WriteSetPayload

BlockMetadata(BlockMetadata)

Transaction to update the block metadata resource at the beginning of a block.

Tuple Fields of BlockMetadata

0: BlockMetadata

StateCheckpoint

Transaction to let the executor update the global state tree and record the root hash in the TransactionInfo

Implementations

impl Transaction

pub fn as_signed_user_txn(&self) -> Result<&SignedTransaction>

pub fn format_for_client(
    &self,
    get_transaction_name: impl Fn(&[u8]) -> String
) -> String

Trait Implementations

impl Arbitrary for Transaction

type Parameters = (<SignedTransaction as Arbitrary>::Parameters, <WriteSetPayload as Arbitrary>::Parameters, <BlockMetadata as Arbitrary>::Parameters)

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

type Strategy = TupleUnion<((u32, Arc<Map<<SignedTransaction as Arbitrary>::Strategy, fn(_: SignedTransaction) -> Self>>), (u32, Arc<Map<<WriteSetPayload as Arbitrary>::Strategy, fn(_: WriteSetPayload) -> Self>>), (u32, Arc<Map<<BlockMetadata as Arbitrary>::Strategy, fn(_: BlockMetadata) -> Self>>), (u32, Arc<fn() -> Self>))>

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

fn arbitrary_with(_top: Self::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 Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CryptoHash for Transaction

type Hasher = TransactionHasher

The associated Hasher type which comes with a unique salt for this type.

fn hash(&self) -> HashValue

Hashes the object and produces a HashValue.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transaction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Transaction> for Transaction

fn eq(&self, other: &Transaction) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Transaction

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

Serialize this value into the given Serde serializer.

impl TryFrom<Transaction> for SignedTransaction

type Error = Error

The type returned in the event of a conversion error.

fn try_from(txn: Transaction) -> Result<Self>

Performs the conversion.

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction