Struct Transaction

pub struct Transaction<'a> {
    pub header: &'a TransactionHeader,
    pub read_slots: &'a [TransactionSlot],
    pub write_slots: &'a [TransactionSlot],
    pub payload: &'a [u128],
    pub seal: &'a [u8],
}

Similar to Transaction, but doesn’t require allow or data ownership.

Can be created with Transaction::as_ref() call.

Fields

header: &'a TransactionHeader

Transaction header

read_slots: &'a [TransactionSlot]

Slots in the form of TransactionSlot that may be read during transaction processing.

These are the only slots that can be used in authorization code.

The code slot of the contract that is being executed and balance of native token are implicitly included and doesn’t need to be specified (see Transaction::read_slots(). Also slots that may also be written to do not need to be repeated in the read slots.

write_slots: &'a [TransactionSlot]

Slots in the form of TransactionSlot that may be written during transaction processing

payload: &'a [u128]

Transaction payload

seal: &'a [u8]

Transaction seal

Implementations

impl<'a> Transaction<'a>

pub fn try_from_bytes(bytes: &'a [u8]) -> Option<(Self, &'a [u8])>

Create an instance from provided correctly aligned bytes.

bytes should be 16-bytes aligned.

See Self::from_bytes_unchecked() for layout details.

Returns an instance and remaining bytes on success.

pub unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> Transaction<'a>

Create an instance from provided bytes without performing any checks for size or alignment.

The internal layout of the owned transaction is following data structures concatenated as bytes (they are carefully picked to ensure alignment):

• TransactionHeader
• SerializedTransactionLengths (with values set to correspond to below contents)
• All read TransactionSlot
• All write TransactionSlot
• Payload as u128s
• Seal as u8s

Safety

Caller must ensure provided bytes are 16-bytes aligned and of sufficient length. Extra bytes beyond necessary are silently ignored if provided.

pub fn to_owned(self) -> Result<OwnedTransaction, OwnedTransactionError>

Create an owned version of this transaction

pub const fn encoded_size(&self) -> usize

Size of the encoded transaction in bytes

pub fn hash(&self) -> TransactionHash

Compute transaction hash.

Note: this computes transaction hash on every call, so worth caching if it is expected to be called often.

pub fn read_slots(&self) -> impl Iterator<Item = TransactionSlot>

Read slots touched by the transaction.

In contrast to read_slots property, this includes implicitly used slots.

pub fn slots(&self) -> impl Iterator<Item = TransactionSlot>

All slots touched by the transaction.

In contrast to read_slots and write_slots properties, this includes implicitly used slots.

Trait Implementations

impl<'a> Clone for Transaction<'a>

fn clone(&self) -> Transaction<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Transaction<'a>

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

Formats the value using the given formatter.

impl WritableBodyTransaction for Transaction<'_>

fn write_into( &self, buffer: &mut OwnedAlignedBuffer, ) -> Result<(), OwnedTransactionError>

Write this transaction into the body

impl<'a> Copy for Transaction<'a>