Struct smart_wallet::Transaction

pub struct Transaction {
    pub smart_wallet: Pubkey,
    pub index: u64,
    pub bump: u8,
    pub proposer: Pubkey,
    pub instructions: Vec<TXInstruction>,
    pub signers: Vec<bool>,
    pub owner_set_seqno: u32,
    pub eta: i64,
    pub executor: Pubkey,
    pub executed_at: i64,
}

A Transaction is a series of instructions that may be executed by a SmartWallet.

Fields

smart_wallet: Pubkey

The SmartWallet account this transaction belongs to.

index: u64

The auto-incremented integer index of the transaction. All transactions on the SmartWallet can be looked up via this index, allowing for easier browsing of a wallet’s historical transactions.

bump: u8

Bump seed.

proposer: Pubkey

The proposer of the Transaction.

instructions: Vec<TXInstruction>

The instruction.

signers: Vec<bool>

signers[index] is true iff [SmartWallet]::owners[index] signed the transaction.

owner_set_seqno: u32

Owner set sequence number.

eta: i64

Estimated time the Transaction will be executed.

• If set to crate::NO_ETA, the transaction may be executed at any time.
• Otherwise, the Transaction may be executed at any point after the ETA has elapsed.

executor: Pubkey

The account that executed the Transaction.

executed_at: i64

When the transaction was executed. -1 if not executed.

Implementations

impl Transaction

pub fn space(instructions: Vec<TXInstruction>) -> usize

Computes the space a Transaction uses.

pub fn num_signers(&self) -> usize

Number of signers.

Trait Implementations

impl AccountDeserialize for Transaction

fn try_deserialize(buf: &mut &[u8]) -> Result<Self, ProgramError>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self, ProgramError>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for Transaction

fn try_serialize<W: Write>(&self, writer: &mut W) -> Result<(), ProgramError>

Serializes the account data into writer.

impl BorshDeserialize for Transaction where
    Pubkey: BorshDeserialize,
    u64: BorshDeserialize,
    u8: BorshDeserialize,
    Pubkey: BorshDeserialize,
    Vec<TXInstruction>: BorshDeserialize,
    Vec<bool>: BorshDeserialize,
    u32: BorshDeserialize,
    i64: BorshDeserialize,
    Pubkey: BorshDeserialize,
    i64: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for Transaction where
    Pubkey: BorshSerialize,
    u64: BorshSerialize,
    u8: BorshSerialize,
    Pubkey: BorshSerialize,
    Vec<TXInstruction>: BorshSerialize,
    Vec<bool>: BorshSerialize,
    u32: BorshSerialize,
    i64: BorshSerialize,
    Pubkey: BorshSerialize,
    i64: BorshSerialize, 

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

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 Debug for Transaction

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

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

impl Discriminator for Transaction

fn discriminator() -> [u8; 8]

impl Owner for Transaction

fn owner() -> Pubkey

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 StructuralPartialEq for Transaction