Struct solders_transaction::Transaction

pub struct Transaction(pub Transaction);

An atomically-commited sequence of instructions.

While :class:~solders.instruction.Instruction\s are the basic unit of computation in Solana, they are submitted by clients in :class:~solders.transaction.Transaction\s containing one or more instructions, and signed by one or more signers.

See the Rust module documentation <https://docs.rs/solana-sdk/latest/solana_sdk/transaction/index.html>_ for more details about transactions.

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 :class:~solders.message.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.

The main Transaction() constructor creates a fully-signed transaction from a Message.

Args: from_keypairs (Sequence[Keypair | Presigner]): The keypairs that are to sign the transaction. message (Message): The message to sign. recent_blockhash (Hash): The id of a recent ledger entry.

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: Transaction

Implementations

impl Transaction

pub fn new( from_keypairs: Vec<Signer>, message: &Message, recent_blockhash: SolderHash ) -> Self

pub fn signatures(&self) -> Vec<Signature>

listSignature: A set of signatures of a serialized :class:~solders.message.Message, signed by the first keys of the message’s :attr:~solders.message.Message.account_keys, where the number of signatures is equal to num_required_signatures of the Message’s :class:~solders.message.MessageHeader.

pub fn message(&self) -> Message

Message: The message to sign.

pub fn new_unsigned(message: Message) -> Self

Create an unsigned transaction from a :class:~solders.message.Message.

Args: message (Message): The transaction’s message.

Returns: Transaction: The unsigned transaction.

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_payer( instructions: Vec<Instruction>, payer: Option<&Pubkey> ) -> Self

Create an unsigned transaction from a list of :class:~solders.instruction.Instruction\s.

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

Returns: Transaction: The unsigned transaction.

Example: >>> from solders.keypair import Keypair >>> from solders.instruction import Instruction >>> 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() >>> tx = Transaction.new_with_payer([instruction], payer.pubkey())

pub fn new_signed_with_payer( instructions: Vec<Instruction>, payer: Option<Pubkey>, signing_keypairs: Vec<Signer>, recent_blockhash: SolderHash ) -> Self

Create a fully-signed transaction from a list of :class:~solders.instruction.Instruction\s.

Args: instructions (SequenceInstruction): The instructions to include in the transaction message. payer (OptionalPubkey, optional): The transaction fee payer. signing_keypairs (Sequence[Keypair | Presigner]): The keypairs that will sign the transaction. recent_blockhash (Hash): The id of a recent ledger entry.

Returns: Transaction: The signed transaction.

Example: >>> from solders.keypair import Keypair >>> from solders.instruction import Instruction >>> 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() >>> blockhash = Hash.default() # replace with a real blockhash >>> tx = Transaction.new_signed_with_payer([instruction], payer.pubkey(), [payer], blockhash);

pub fn new_with_compiled_instructions( from_keypairs: Vec<Signer>, keys: Vec<Pubkey>, recent_blockhash: SolderHash, program_ids: Vec<Pubkey>, instructions: Vec<CompiledInstruction> ) -> Self

Create a fully-signed transaction from pre-compiled instructions.

Args: from_keypairs (Sequence[Keypair | Presigner]): The keys used to sign the transaction. keys (SequencePubkey): The keys for the transaction. These are the program state instances or lamport recipient keys. recent_blockhash (Hash): The PoH hash. program_ids (SequencePubkey): The keys that identify programs used in the instruction vector. instructions (SequenceInstruction): Instructions that will be executed atomically.

Returns: Transaction: The signed transaction.

pub fn populate(message: Message, signatures: Vec<Signature>) -> Self

Create a fully-signed transaction from a message and its signatures.

Args: message (Message): The transaction message. signatures (SequenceSignature): The message’s signatures.

Returns: Message: The signed transaction.

Example:

>>> from solders.keypair import Keypair
>>> from solders.instruction import Instruction
>>> 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()
>>> blockhash = Hash.default()  # replace with a real blockhash
>>> tx = Transaction.new_signed_with_payer([instruction], payer.pubkey(), [payer], blockhash);
>>> assert tx == Transaction.populate(tx.message, tx.signatures)

pub fn data(&self, instruction_index: usize) -> &[u8]

Get the data for an instruction at the given index.

Args: instruction_index (int): index into the instructions vector of the transaction’s message.

Returns: bytes: The instruction data.

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

Get the :class:~solders.pubkey.Pubkey of an account required by one of the instructions in the transaction.

Returns None if instruction_index is greater than or equal to the number of instructions in the transaction; or if accounts_index is greater than or equal to the number of accounts in the instruction.

Args: instruction_index (int): index into the instructions vector of the transaction’s message. account_index (int): index into the acounts list of the message’s compiled_instructions.

Returns: OptionalPubkey: The account key.

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

Get the :class:~solders.pubkey.Pubkey of a signing account required by one of the instructions in the transaction.

The transaction does not need to be signed for this function to return a signing account’s pubkey.

Returns None if the indexed account is not required to sign the transaction. Returns None if the [signatures] field does not contain enough elements to hold a signature for the indexed account (this should only be possible if Transaction has been manually constructed).

Returns None if instruction_index is greater than or equal to the number of instructions in the transaction; or if accounts_index is greater than or equal to the number of accounts in the instruction.

Args: instruction_index (int): index into the instructions vector of the transaction’s message. account_index (int): index into the acounts list of the message’s compiled_instructions.

Returns: OptionalPubkey: The account key.

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

Return the serialized message data to sign.

Returns: bytes: The serialized message data.

pub fn sign( &mut self, keypairs: Vec<Signer>, recent_blockhash: SolderHash ) -> PyResult<()>

Sign the transaction, returning any errors.

This method fully signs a transaction with all required signers, which must be present in the keypairs list. To sign with only some of the required signers, use :meth:Transaction.partial_sign.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash] field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Errors:

Signing will fail if some required signers are not provided in keypairs; or, if the transaction has previously been partially signed, some of the remaining required signers are not provided in keypairs. In other words, the transaction must be fully signed as a result of calling this function.

Signing will fail for any of the reasons described in the documentation for :meth:Transaction.partial_sign.

Args: keypairs (Sequence[Keypair | Presigner]): The signers for the transaction. recent_blockhash (Hash): The id of a recent ledger entry.

pub fn partial_sign( &mut self, keypairs: Vec<Signer>, recent_blockhash: SolderHash ) -> PyResult<()>

Sign the transaction with a subset of required keys, returning any errors.

Unlike :meth:Transaction.sign, this method does not require all keypairs to be provided, allowing a transaction to be signed in multiple steps.

It is permitted to sign a transaction with the same keypair multiple times.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Errors:

Signing will fail if

• The transaction’s :class:~solders.message.Message is malformed such that the number of required signatures recorded in its header (num_required_signatures) is greater than the length of its account keys (account_keys).
• Any of the provided signers in keypairs is not a required signer of the message.
• Any of the signers is a :class:~solders.presigner.Presigner, and its provided signature is incorrect.

Args: keypairs (Sequence[Keypair | Presigner]): The signers for the transaction. recent_blockhash (Hash): The id of a recent ledger entry.

pub fn verify(&self) -> PyResult<()>

Verifies that all signers have signed the message.

Raises: TransactionError: if the check fails.

pub fn verify_and_hash_message(&self) -> PyResult<SolderHash>

Verify the transaction and hash its message.

Returns: Hash: The blake3 hash of the message.

Raises: TransactionError: if the check fails.

pub fn verify_with_results(&self) -> Vec<bool>

Verifies that all signers have signed the message.

Returns: listbool: a list with the length of required signatures, where each element is either True if that signer has signed, or False if not.

pub fn get_signing_keypair_positions( &self, pubkeys: Vec<Pubkey> ) -> PyResult<Vec<Option<usize>>>

Get the positions of the pubkeys in account_keys associated with signing keypairs.

Args: pubkeys (SequencePubkey): The pubkeys to find.

Returns:
    list[Optional[int]]: The pubkey positions.

pub fn replace_signatures( &mut self, signers: Vec<(Pubkey, Signature)> ) -> PyResult<()>

Replace all the signatures and pubkeys.

Args: signers (Sequence[Tuple[Pubkey, Signature]]): The replacement pubkeys and signatures.

pub fn is_signed(&self) -> bool

Check if the transaction has been signed.

Returns: bool: True if the transaction has been signed.

pub fn uses_durable_nonce(&self) -> Option<CompiledInstruction>

See https://docs.rs/solana-sdk/latest/solana_sdk/transaction/fn.uses_durable_nonce.html

pub fn sanitize(&self) -> PyResult<()>

Sanity checks the Transaction properties.

pub fn new_default() -> Self

Return a new default transaction.

Returns: Transaction: The default transaction.

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

Deserialize a serialized Transaction object.

Args: data (bytes): the serialized Transaction.

Returns: Transaction: the deserialized Transaction.

Example: >>> from solders.transaction import Transaction >>> tx = Transaction.default() >>> assert Transaction.from_bytes(bytes(tx)) == tx

pub fn get_nonce_pubkey_from_instruction( &self, ix: &CompiledInstruction ) -> Option<Pubkey>

Deprecated in the Solana Rust SDK, expose here only for testing.

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<Transaction> for Transaction

fn as_ref(&self) -> &TransactionOriginal

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

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommonMethods<'_> for Transaction

fn py_to_json(&self) -> String

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

impl CommonMethodsCore for Transaction

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 Transaction

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

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Transaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Transaction

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

Formats the value using the given formatter.

impl From<Transaction> for Transaction

fn from(original: TransactionOriginal) -> Transaction

Converts to this type from the input type.

impl From<Transaction> for Transaction

fn from(original: Transaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for VersionedTransaction

fn from(t: Transaction) -> Self

Converts to this type from the input type.

impl IntoPy<Py<PyAny>> for Transaction

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

Performs the conversion.

impl PartialEq for Transaction

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

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

impl PyBytesGeneral for Transaction

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

impl PyClass for Transaction

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Transaction

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<Transaction>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<Transaction>

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

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

impl PyFromBytesBincode<'_> for Transaction

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

impl PyFromBytesGeneral for Transaction

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

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

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

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

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

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

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

impl PyMethods<Transaction> for PyClassImplCollector<Transaction>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Transaction

type AsRefTarget = PyCell<Transaction>

Utility type to make Py::as_ref work.

const NAME: &'static str = "Transaction"

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 Transaction

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

impl Serialize for Transaction

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 Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction