Struct Message

pub struct Message(pub Message);

A Solana transaction message.

Some constructors accept an optional payer, the account responsible for paying the cost of executing a transaction. In most cases, callers should specify the payer explicitly in these constructors. In some cases though, the caller is not required to specify the payer, but is still allowed to: in the Message object, the first account is always the fee-payer, so if the caller has knowledge that the first account of the constructed transaction’s Message is both a signer and the expected fee-payer, then redundantly specifying the fee-payer is not strictly required.

Args: instructions (SequenceInstruction): The instructions to include in the message. payer (OptionalPubkey): The fee payer. Defaults to None.

Example: >>> from solders.message import Message >>> from solders.keypair import Keypair >>> from solders.instruction import Instruction >>> from solders.hash import Hash >>> from solders.transaction import Transaction >>> from solders.pubkey import Pubkey >>> program_id = Pubkey.default() >>> arbitrary_instruction_data = bytes([1]) >>> accounts = [] >>> instruction = Instruction(program_id, arbitrary_instruction_data, accounts) >>> payer = Keypair() >>> message = Message([instruction], payer.pubkey()) >>> blockhash = Hash.default() # replace with a real blockhash >>> tx = Transaction([payer], message, blockhash)

Tuple Fields

0: Message

Implementations

impl Message

pub fn new(instructions: Vec<Instruction>, payer: Option<&Pubkey>) -> Self

pub fn header(&self) -> MessageHeader

MessageHeader: The message header, identifying signed and read-only account_keys.

pub fn account_keys(&self) -> Vec<Pubkey>

listPubkey: All the account keys used by this transaction.

pub fn recent_blockhash(&self) -> SolderHash

Hash: The id of a recent ledger entry.

pub fn instructions(&self) -> Vec<CompiledInstruction>

listCompiledInstruction: Programs that will be executed in sequence and committed in one atomic transaction if all succeed.

pub fn new_with_blockhash( instructions: Vec<Instruction>, payer: Option<Pubkey>, blockhash: &SolderHash, ) -> Self

Create a new message while setting the blockhash.

Args: instructions (SequenceInstruction): The instructions to include in the message. payer (OptionalPubkey): The fee payer. Defaults to None. blockhash (Hash): a recent blockhash.

Returns: Message: The message object.

Example: >>> from typing import List >>> from solders.message import Message >>> from solders.keypair import Keypair >>> from solders.pubkey import Pubkey >>> from solders.instruction import Instruction, AccountMeta >>> from solders.hash import Hash >>> from solders.transaction import Transaction >>> program_id = Pubkey.default() >>> blockhash = Hash.default() # replace with a real blockhash >>> arbitrary_instruction_data = bytes([1]) >>> accounts: List[AccountMeta] = [] >>> instruction = Instruction(program_id, arbitrary_instruction_data, accounts) >>> payer = Keypair() >>> message = Message.new_with_blockhash([instruction], payer.pubkey(), blockhash) >>> tx = Transaction.new_unsigned(message) >>> tx.sign([payer], tx.message.recent_blockhash)

pub fn new_with_nonce( instructions: Vec<Instruction>, payer: Option<Pubkey>, nonce_account_pubkey: &Pubkey, nonce_authority_pubkey: &Pubkey, ) -> Self

Create a new message for a nonced transaction <https://docs.solana.com/implemented-proposals/durable-tx-nonces>_.

Args: instructions (SequenceInstruction): The instructions to include in the message. payer (OptionalPubkey): The fee payer. Defaults to None. nonce_account_pubkey (Pubkey): The nonce account pubkey. nonce_authority_pubkey (Pubkey): The nonce account authority (for advance and close).

In this type of transaction, the blockhash is replaced with a durable transaction nonce, allowing for extended time to pass between the transaction’s signing and submission to the blockchain.

Example: >>> from typing import List >>> from solders.message import Message >>> from solders.keypair import Keypair >>> from solders.pubkey import Pubkey >>> from solders.instruction import Instruction, AccountMeta >>> from solders.hash import Hash >>> from solders.transaction import Transaction >>> program_id = Pubkey.default() >>> blockhash = Hash.default() # replace with a real blockhash >>> arbitrary_instruction_data = bytes([1]) >>> accounts: List[AccountMeta] = [] >>> instruction = Instruction(program_id, arbitrary_instruction_data, accounts) >>> payer = Keypair() >>> nonce_account = Pubkey.default() # replace with a real nonce account >>> message = Message.new_with_nonce([instruction], payer.pubkey(), nonce_account, payer.pubkey()) >>> # This transaction will need to be signed later, using the blockhash stored in the nonce account. >>> tx = Transaction.new_unsigned(message)

pub fn new_with_compiled_instructions( num_required_signatures: u8, num_readonly_signed_accounts: u8, num_readonly_unsigned_accounts: u8, account_keys: Vec<Pubkey>, recent_blockhash: SolderHash, instructions: Vec<CompiledInstruction>, ) -> Self

Create a new message by specifying all the fields required for the message, including the :class:MessageHeader fields.

Args: num_required_signatures (int): The number of signatures required for this message to be considered valid. The signers of those signatures must match the first num_required_signatures of :attr:Message.account_keys. num_readonly_signed_accounts (int): The last num_readonly_signed_accounts of the signed keys are read-only accounts. num_readonly_unsigned_accounts (int): The last num_readonly_unsigned_accounts of the unsigned keys are read-only accounts. account_keys (listPubkey): All the account keys used by this transaction. recent_blockhash (Hash): The id of a recent ledger entry. instructions (listCompiledInstruction): Programs that will be executed in sequence and committed in one atomic transaction if all succeed.

Returns: Message: The message object.

pub fn hash(&self) -> SolderHash

Compute the blake3 hash of this transaction’s message.

Returns: Hash: The blake3 hash.

pub fn hash_raw_message(message_bytes: &[u8]) -> SolderHash

Compute the blake3 hash of a raw transaction message.

Returns: Hash: The blake3 hash.

pub fn compile_instruction(&self, ix: &Instruction) -> CompiledInstruction

Convert an :class:~solders.Instruction into a :class:~solders.instruction.CompiledInstruction using self.account_keys.

Returns: CompiledInstruction: The compiled instruction.

pub fn program_id(&self, instruction_index: usize) -> Option<Pubkey>

Return the program ID of an instruction at a particular index in the message.

Args: instruction_index (int): The position of the instruction in the message’s list of instructions.

Returns: Pubkey: The program ID.

pub fn program_index(&self, instruction_index: usize) -> Option<usize>

Return the program_id_index of the instruction at instruction_index in the message.

Args: instruction_index (int): The position of the instruction in the message’s list of instructions.

Returns: int: The program ID index.

pub fn program_ids(&self) -> Vec<Pubkey>

Return the program ID of each instruction in the message.

Returns: listPubkey: The program IDs.

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

Check if key_index is contained in the accounts of any of the message’s instructions.

Args: key_index (int): The index to check.

Returns: bool: True if the key is passed to the program.

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

Check if the program_id_index of any of the message’s instructions matches key_index.

Args: key_index (int): The index to check.

Returns: bool: The result of the check.

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

Check if the key is passed to the program OR if the key is not called as program.

Args: key_index (int): The index to check.

Returns: bool: The result of the check.

pub fn program_position(&self, index: usize) -> Option<usize>

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.program_position

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

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.maybe_executable

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

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.is_writable

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

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.is_signer

pub fn signer_keys(&self) -> Vec<Pubkey>

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.signer_keys

pub fn has_duplicates(&self) -> bool

Check if account_keys has any duplicate keys.

Returns: bool: True if there are duplicates.

pub fn is_upgradeable_loader_present(&self) -> bool

See https://docs.rs/solana-sdk/latest/solana_sdk/message/legacy/struct.Message.html#method.is_upgradeable_loader_present

pub fn new_default() -> Self

Create a new default Message.

Returns: Message: default Message.

pub fn from_bytes(data: &[u8]) -> PyResult<Self>

Deserialize a serialized Message object.

Args: data (bytes): The serialized Message.

Returns: Message: The deserialized Message.

Example: >>> from solders.pubkey import Pubkey >>> from solders.instruction import AccountMeta, Instruction >>> from solders.message import Message >>> from_pubkey = Pubkey.new_unique() >>> to_pubkey = Pubkey.new_unique() >>> program_id = Pubkey.new_unique() >>> instruction_data = bytes([1]) >>> accounts = [AccountMeta(from_pubkey, is_signer=True, is_writable=True), AccountMeta(to_pubkey, is_signer=True, is_writable=True)] >>> instruction = Instruction(program_id, instruction_data, accounts) >>> message = Message([instruction]) >>> serialized = bytes(message) >>> assert Message.from_bytes(serialized) == message

pub fn __richcmp__(&self, other: &Self, op: CompareOp) -> PyResult<bool>

pub fn __bytes__<'a>(&self, py: Python<'a>) -> &'a PyBytes

pub fn __str__(&self) -> String

pub fn __repr__(&self) -> String

pub fn __reduce__(&self) -> PyResult<(PyObject, PyObject)>

pub fn to_json(&self) -> String

Convert to a JSON string.

pub fn from_json(raw: &str) -> PyResult<Self>

Build from a JSON string.

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 CommonMethods<'_> for Message

fn py_to_json(&self) -> String

fn py_from_json(raw: &'a str) -> Result<Self, PyErr>

impl CommonMethodsCore for Message

fn pybytes<'b>(&self, py: Python<'b>) -> &'b PyBytes

fn pystr(&self) -> String

fn pyrepr(&self) -> String

fn py_from_bytes(raw: &[u8]) -> Result<Self, PyErr>

fn pyreduce(&self) -> Result<(Py<PyAny>, Py<PyAny>), PyErr>

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

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

Formats the value using the given formatter.

impl From<&Message> for Message

fn from(message: &Message) -> Self

Converts to this type from the input type.

impl From<Message> for Message

fn from(original: MessageOriginal) -> Message

Converts to this type from the input type.

impl From<Message> for Message

fn from(original: Message) -> Self

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for Message

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

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

fn pybytes_general<'a>(&self, py: Python<'a>) -> &'a PyBytes

impl PyClass for Message

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Message

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Message>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<Message> for PyClassImplCollector<Message>

fn new_text_signature(self) -> Option<&'static str>

impl PyFromBytesBincode<'_> for Message

fn py_from_bytes_bincode(raw: &'b [u8]) -> Result<Self, PyErr>

impl PyFromBytesGeneral for Message

fn py_from_bytes_general(raw: &[u8]) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a Message

type Holder = Option<PyRef<'py, Message>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut Message

type Holder = Option<PyRefMut<'py, Message>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyMethods<Message> for PyClassImplCollector<Message>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Message

const NAME: &'static str = "Message"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

type AsRefTarget = PyCell<Message>

Utility type to make Py::as_ref work.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl RichcmpEqualityOnly for Message

fn richcmp(&self, other: &Self, op: CompareOp) -> Result<bool, PyErr>

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