Struct LoadedMessage

pub struct LoadedMessage<'a> {
    pub message: Cow<'a, Message>,
    pub loaded_addresses: Cow<'a, LoadedAddresses>,
    pub is_writable_account_cache: Vec<bool>,
}

Combination of a version #0 message and its loaded addresses

Fields

message: Cow<'a, Message>

Message which loaded a collection of lookup table addresses

loaded_addresses: Cow<'a, LoadedAddresses>

Addresses loaded with on-chain address lookup tables

is_writable_account_cache: Vec<bool>

List of boolean with same length as account_keys(), each boolean value indicates if corresponding account key is writable or not.

Implementations

impl<'a> LoadedMessage<'a>

pub fn new( message: Message, loaded_addresses: LoadedAddresses, reserved_account_keys: &HashSet<Pubkey>, ) -> Self

pub fn new_borrowed( message: &'a Message, loaded_addresses: &'a LoadedAddresses, reserved_account_keys: &HashSet<Pubkey>, ) -> Self

pub fn account_keys(&self) -> AccountKeys<'_>

Returns the full list of static and dynamic account keys that are loaded for this message.

pub fn static_account_keys(&self) -> &[Pubkey]

Returns the list of static account keys that are loaded for this message.

pub fn has_duplicates(&self) -> bool

Returns true if any account keys are duplicates

pub fn is_writable(&self, key_index: usize) -> bool

pub fn is_signer(&self, i: usize) -> bool

pub fn demote_program_id(&self, i: usize) -> bool

pub fn is_key_called_as_program(&self, key_index: usize) -> bool

Returns true if the account at the specified index is called as a program by an instruction

pub fn is_upgradeable_loader_present(&self) -> bool

Returns true if any account is the bpf upgradeable loader

Trait Implementations

impl<'a> Clone for LoadedMessage<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LoadedMessage<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for LoadedMessage<'a>

fn eq(&self, other: &LoadedMessage<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for LoadedMessage<'a>

impl<'a> StructuralPartialEq for LoadedMessage<'a>