Struct Message 

pub struct Message {
    pub header: MessageHeader,
    pub config: TransactionConfig,
    pub lifetime_specifier: Hash,
    pub account_keys: Vec<Address>,
    pub instructions: Vec<CompiledInstruction>,
}

Available on non-target_os=solana only.

A V1 transaction message (SIMD-0385) supporting 4KB transactions with inline compute budget.

Important

This message format does not support bincode binary serialization. Use the provided serialize and deserialize functions for binary encoding/decoding.

Fields

header: MessageHeader

The message header describing signer/readonly account counts.

config: TransactionConfig

Configuration for transaction parameters.

lifetime_specifier: Hash

The lifetime specifier (blockhash) that determines when this transaction expires.

account_keys: Vec<Address>

All account addresses referenced by this message.

The length should be specified as an u8. Unlike V0, V1 does not support address lookup tables. The ordering of the addresses is unchanged from prior transaction formats:

• num_required_signatures-num_readonly_signed_accounts additional addresses for which the transaction contains signatures and are loaded as writable, of which the first is the fee payer.

• num_readonly_signed_accounts addresses for which the transaction contains signatures and are loaded as readonly.

• num_addresses-num_required_signatures-num_readonly_unsigned_accounts addresses for which the transaction does not contain signatures and are loaded as writable.

• num_readonly_unsigned_accounts addresses for which the transaction does not contain signatures and are loaded as readonly.

instructions: Vec<CompiledInstruction>

Program instructions to execute.

Implementations

impl Message

pub fn new( header: MessageHeader, config: TransactionConfig, lifetime_specifier: Hash, account_keys: Vec<Address>, instructions: Vec<CompiledInstruction>, ) -> Self

Create a new V1 message.

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

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

Examples

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

use anyhow::Result;
use solana_instruction::{AccountMeta, Instruction};
use solana_keypair::Keypair;
use solana_message::{VersionedMessage, v1};
use solana_address::Address;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::versioned::VersionedTransaction;

fn create_v1_tx(
    client: &RpcClient,
    instruction: Instruction,
    payer: &Keypair,
) -> Result<VersionedTransaction> {
    let blockhash = client.get_latest_blockhash()?;
    let tx = VersionedTransaction::try_new(
        VersionedMessage::V1(v1::Message::try_compile(
            &payer.pubkey(),
            &[instruction],
            blockhash,
        )?),
        &[payer],
    )?;

    Ok(tx)
}

pub fn try_compile_with_config( payer: &Address, instructions: &[Instruction], recent_blockhash: Hash, config: TransactionConfig, ) -> Result<Self, CompileError>

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

Examples

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

use anyhow::Result;
use solana_instruction::{AccountMeta, Instruction};
use solana_keypair::Keypair;
use solana_message::{VersionedMessage, v1, v1::TransactionConfig};
use solana_address::Address;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::versioned::VersionedTransaction;

fn create_v1_tx(
    client: &RpcClient,
    instruction: Instruction,
    payer: &Keypair,
) -> Result<VersionedTransaction> {
    let blockhash = client.get_latest_blockhash()?;
    let tx = VersionedTransaction::try_new(
        VersionedMessage::V1(v1::Message::try_compile_with_config(
            &payer.pubkey(),
            &[instruction],
            blockhash,
            TransactionConfig::empty().with_compute_unit_limit(100),
        )?),
        &[payer],
    )?;

    Ok(tx)
}

pub fn fee_payer(&self) -> Option<&Address>

Returns the fee payer address (first account key).

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

Account keys are ordered with signers first: [signers..., non-signers...]. An index falls in the signer region if it’s less than num_required_signatures.

pub fn is_signer_writable(&self, index: usize) -> bool

Returns true if the account at this index is both a signer and writable.

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

Returns true if any instruction invokes the account at this index as a program.

pub fn is_upgradeable_loader_present(&self) -> bool

Returns true if the BPF upgradeable loader is present in the account keys.

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.

Important

Before loading addresses, we can’t demote write locks properly so this should not be used by the runtime. The reserved_account_keys parameter is optional to allow clients to approximate writability without requiring fetching the latest set of reserved account keys.

Program accounts are demoted from writable to readonly, unless the upgradeable loader is present in which case they are left as writable since upgradeable programs need to be writable for upgrades.

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

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

Available on crate feature wincode only.

Serialize this message with the V1 version prefix byte.

pub fn size(&self) -> usize

Calculate the serialized size of the message in bytes.

pub fn validate(&self) -> Result<(), MessageError>

Trait Implementations

impl AbiExample for Message

fn example() -> Self

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate 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

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<Self, __D::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 Sanitize for Message

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

impl<'de, C: Config> SchemaRead<'de, C> for Message

Available on crate feature wincode only.

type Dst = Message

fn read( reader: impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.

fn get(reader: impl Reader<'de>) -> Result<Self::Dst, ReadError>

Read Self::Dst from reader into a new Self::Dst.

impl<C: ConfigCore> SchemaWrite<C> for Message

Available on crate feature wincode only.

type Src = Message

fn size_of(src: &Self::Src) -> WriteResult<usize>

Get the serialized size of Self::Src.

fn write(writer: impl Writer, src: &Self::Src) -> WriteResult<()>

Write Self::Src to writer.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.

impl Serialize for Message

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Message

impl StructuralPartialEq for Message