Enum diem_sdk::types::transaction::Transaction

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

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.

GenesisTransaction(WriteSetPayload)

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

BlockMetadata(BlockMetadata)

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

Implementations

impl Transaction

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

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) -> Transaction>>), (u32, Arc<Map<<WriteSetPayload as Arbitrary>::Strategy, fn(_: WriteSetPayload) -> Transaction>>), (u32, Arc<Map<<BlockMetadata as Arbitrary>::Strategy, fn(_: BlockMetadata) -> Transaction>>))>

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

fn arbitrary_with( _top: <Transaction as Arbitrary>::Parameters ) -> <Transaction 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 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<(), Error>

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl From<Transaction> for TransactionDataView

fn from(tx: Transaction) -> TransactionDataView

Converts to this type from the input type.

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Transaction

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 TryFrom<Transaction> for SignedTransaction

type Error = Error

The type returned in the event of a conversion error.

fn try_from(txn: Transaction) -> Result<SignedTransaction, Error>

Performs the conversion.

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction