Struct solders_instruction::Instruction

pub struct Instruction(pub Instruction);

A directive for a single invocation of a Solana program.

An instruction specifies which program it is calling, which accounts it may read or modify, and additional data that serves as input to the program. One or more instructions are included in transactions submitted by Solana clients. Instructions are also used to describe cross-program invocations <https://docs.solana.com/developing/programming-model/calling-between-programs/>_.

During execution, a program will receive a list of account data as one of its arguments, in the same order as specified during Instruction construction.

While Solana is agnostic to the format of the instruction data, it has built-in support for serialization via borsh <https://docs.rs/borsh/latest/borsh/>_ and bincode <https://docs.rs/bincode/latest/bincode/>_.

When constructing an Instruction, a list of all accounts that may be read or written during the execution of that instruction must be supplied as :class:AccountMeta values.

Specifying Account Metadata

Any account whose data may be mutated by the program during execution must be specified as writable. During execution, writing to an account that was not specified as writable will cause the transaction to fail. Writing to an account that is not owned by the program will cause the transaction to fail.

Any account whose lamport balance may be mutated by the program during execution must be specified as writable. During execution, mutating the lamports of an account that was not specified as writable will cause the transaction to fail. While subtracting lamports from an account not owned by the program will cause the transaction to fail, adding lamports to any account is allowed, as long is it is mutable.

Accounts that are not read or written by the program may still be specified in an Instruction’s account list. These will affect scheduling of program execution by the runtime, but will otherwise be ignored.

When building a transaction, the Solana runtime coalesces all accounts used by all instructions in that transaction, along with accounts and permissions required by the runtime, into a single account list. Some accounts and account permissions required by the runtime to process a transaction are not required to be included in an Instruction’s account list. These include:

• The program ID: it is a separate field of Instruction
• The transaction’s fee-paying account: it is added during :class:~solders.message.Message construction. A program may still require the fee payer as part of the account list if it directly references it.

Programs may require signatures from some accounts, in which case they should be specified as signers during Instruction construction. The program must still validate during execution that the account is a signer.

Args: program_id (Pubkey): Pubkey of the program that executes this instruction. data (bytes): Opaque data passed to the program for its own interpretation. accounts (listAccountMeta): Metadata describing accounts that should be passed to the program.

Tuple Fields

0: Instruction

Implementations

impl Instruction

pub fn new(program_id: &Pubkey, data: &[u8], accounts: Vec<AccountMeta>) -> Self

pub fn program_id(&self) -> Pubkey

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

pub fn accounts(&self) -> Vec<AccountMeta>

pub fn set_accounts(&mut self, accounts: Vec<AccountMeta>)

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

Deserialize a serialized Instruction object.

Args: data (bytes): the serialized Instruction.

Returns: Instruction: the deserialized Instruction.

Example: >>> from solders.pubkey import Pubkey >>> from solders.instruction import AccountMeta, Instruction >>> 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) >>> serialized = bytes(instruction) >>> assert Instruction.from_bytes(serialized) == instruction

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 AsRef<Instruction> for Instruction

fn as_ref(&self) -> &InstructionOriginal

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommonMethods<'_> for Instruction

fn py_to_json(&self) -> String

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

impl CommonMethodsCore for Instruction

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 Instruction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instruction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Instruction

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

Formats the value using the given formatter.

impl From<Instruction> for Instruction

fn from(original: InstructionOriginal) -> Instruction

Converts to this type from the input type.

impl From<Instruction> for Instruction

fn from(original: Instruction) -> Self

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for Instruction

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

Performs the conversion.

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PyBytesBincode for Instruction

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

impl PyBytesGeneral for Instruction

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

impl PyClass for Instruction

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Instruction

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 Layout = PyCell<Instruction>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<Instruction>

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<Instruction> for PyClassImplCollector<Instruction>

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

impl PyFromBytesBincode<'_> for Instruction

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

impl PyFromBytesGeneral for Instruction

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

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

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

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

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

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

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

impl PyMethods<Instruction> for PyClassImplCollector<Instruction>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Instruction

type AsRefTarget = PyCell<Instruction>

Utility type to make Py::as_ref work.

const NAME: &'static str = "Instruction"

Class name.

const MODULE: Option<&'static str> = _

Module name, if any.

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 Instruction

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

impl Serialize for Instruction

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 Instruction

impl StructuralEq for Instruction

impl StructuralPartialEq for Instruction