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],
    /* private fields */
}

Similar to OwnedTransaction, but doesn’t require alloc or data ownership.

Can be created with Transaction::try_from_bytes() or borrowed from OwnedTransaction::transaction().

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 don’t need to be specified (see Transaction::read_slots()). 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.

The layout 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

Payload and seal lengths in SerializedTransactionLengths are in bytes.

Returns an instance and remaining bytes on success.

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) -> impl Deref<Target = TransactionHash> + Send + Sync

Compute transaction hash.

Note that this method hashes the whole serialized transaction. The result is then cached if alloc feature is enabled or when compiled for OS target that is not none.

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) -> Self

Returns a duplicate 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<(), OwnedLeafShardBodyError>

Write this transaction into the body.