Struct Message

pub struct Message {
    pub header: MessageHeader,
    pub account_keys: Vec<Address>,
    pub recent_blockhash: Hash,
    pub instructions: Vec<CompiledInstruction>,
    pub address_table_lookups: Vec<MessageAddressTableLookup>,
}

A Solana transaction message (v0).

This message format supports succinct account loading with on-chain address lookup tables.

See the crate documentation for further description.

Fields

header: MessageHeader

The message header, identifying signed and read-only account_keys. Header values only describe static account_keys, they do not describe any additional account keys loaded via address table lookups.

account_keys: Vec<Address>

List of accounts loaded by this transaction.

recent_blockhash: Hash

The blockhash of a recent block.

instructions: Vec<CompiledInstruction>

Instructions that invoke a designated program, are executed in sequence, and committed in one atomic transaction if all succeed.

Notes

Program indexes must index into the list of message account_keys because program id’s cannot be dynamically loaded from a lookup table.

Account indexes must index into the list of addresses constructed from the concatenation of three key lists:

1. message account_keys
2. ordered list of keys loaded from writable lookup table indexes
3. ordered list of keys loaded from readable lookup table indexes

address_table_lookups: Vec<MessageAddressTableLookup>

List of address table lookups used to load additional accounts for this transaction.

Implementations

impl Message

pub fn sanitize(&self) -> Result<(), SanitizeError>

Sanitize message fields and compiled instruction indexes

impl Message

pub fn try_compile( payer: &Address, instructions: &[Instruction], address_lookup_table_accounts: &[AddressLookupTableAccount], recent_blockhash: Hash, ) -> Result<Message, CompileError>

Create a signable transaction message from a payer public key, recent_blockhash, list of instructions, and a list of address_lookup_table_accounts.

Examples

This example uses the solana_rpc_client, solana_account, and anyhow crates.

use anyhow::Result;
use solana_address_lookup_table_interface::state::{AddressLookupTable, LookupTableMeta};
use solana_instruction::{AccountMeta, Instruction};
use solana_keypair::Keypair;
use solana_message::{AddressLookupTableAccount, VersionedMessage, v0};
use solana_address::Address;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::versioned::VersionedTransaction;

fn create_tx_with_address_table_lookup(
    client: &RpcClient,
    instruction: Instruction,
    address_lookup_table_key: Address,
    payer: &Keypair,
) -> Result<VersionedTransaction> {
    let raw_account = client.get_account(&address_lookup_table_key)?;
    let address_lookup_table = AddressLookupTable::deserialize(&raw_account.data)?;
    let address_lookup_table_account = AddressLookupTableAccount {
        key: address_lookup_table_key,
        addresses: address_lookup_table.addresses.to_vec(),
    };

    let blockhash = client.get_latest_blockhash()?;
    let tx = VersionedTransaction::try_new(
        VersionedMessage::V0(v0::Message::try_compile(
            &payer.pubkey(),
            &[instruction],
            &[address_lookup_table_account],
            blockhash,
        )?),
        &[payer],
    )?;

    Ok(tx)
}

pub fn serialize(&self) -> Vec<u8>

Serialize this message with a version #0 prefix using bincode encoding.

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_maybe_writable( &self, key_index: usize, reserved_account_keys: Option<&HashSet<Address>>, ) -> bool

Returns true if the account at the specified index was requested as writable. Before loading addresses, we can’t demote write locks properly so this should not be used by the runtime. The reserved_account_keys param is optional to allow clients to approximate writability without requiring fetching the latest set of reserved account keys.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl Default for Message

fn default() -> Message

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Message

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Message

fn eq(&self, other: &Message) -> 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 SerializableMessage for Message

fn serialize(&self) -> Vec<u8>

impl Serialize for Message

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 Eq for Message

impl StructuralPartialEq for Message