Struct solana_sdk::transaction::Transaction

pub struct Transaction {
    pub signatures: Vec<Signature>,
    pub message: Message,
}

An atomic transaction

Fields

signatures: Vec<Signature>

A set of digital signatures of account_keys, program_ids, recent_blockhash, and instructions, signed by the first signatures.len() keys of account_keys NOTE: Serialization-related changes must be paired with the direct read at sigverify.

message: Message

The message to sign.

Implementations

impl Transaction

pub fn new_unsigned(message: Message) -> Self

pub fn new_with_payer(
    instructions: &[Instruction],
    payer: Option<&Pubkey>
) -> Self

pub fn new_signed_with_payer<T: Signers>(
    instructions: &[Instruction],
    payer: Option<&Pubkey>,
    signing_keypairs: &T,
    recent_blockhash: Hash
) -> Self

Create a signed transaction with the given payer.

Panics

Panics when signing fails.

pub fn new<T: Signers>(
    from_keypairs: &T,
    message: Message,
    recent_blockhash: Hash
) -> Transaction

Create a signed transaction.

Panics

Panics when signing fails.

pub fn new_with_compiled_instructions<T: Signers>(
    from_keypairs: &T,
    keys: &[Pubkey],
    recent_blockhash: Hash,
    program_ids: Vec<Pubkey>,
    instructions: Vec<CompiledInstruction>
) -> Self

Create a signed transaction

• from_keypairs - The keys used to sign the transaction.
• keys - The keys for the transaction. These are the program state instances or lamport recipient keys.
• recent_blockhash - The PoH hash.
• program_ids - The keys that identify programs used in the instruction vector.
• instructions - Instructions that will be executed atomically.

Panics

Panics when signing fails.

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

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

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

pub fn message(&self) -> &Message

Return a message containing all data that should be signed.

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

Return the serialized message data to sign.

pub fn sign<T: Signers>(&mut self, keypairs: &T, recent_blockhash: Hash)

Check keys and keypair lengths, then sign this transaction.

Panics

Panics when signing fails, use Transaction::try_sign to handle the error.

pub fn partial_sign<T: Signers>(&mut self, keypairs: &T, recent_blockhash: Hash)

Sign using some subset of required keys if recent_blockhash is not the same as currently in the transaction, clear any prior signatures and update recent_blockhash

Panics

Panics when signing fails, use Transaction::try_partial_sign to handle the error.

pub fn partial_sign_unchecked<T: Signers>(
    &mut self,
    keypairs: &T,
    positions: Vec<usize>,
    recent_blockhash: Hash
)

Sign the transaction and place the signatures in their associated positions in signatures without checking that the positions are correct.

Panics

Panics when signing fails, use Transaction::try_partial_sign_unchecked to handle the error.

pub fn try_sign<T: Signers>(
    &mut self,
    keypairs: &T,
    recent_blockhash: Hash
) -> Result<(), SignerError>

Check keys and keypair lengths, then sign this transaction, returning any signing errors encountered

pub fn try_partial_sign<T: Signers>(
    &mut self,
    keypairs: &T,
    recent_blockhash: Hash
) -> Result<(), SignerError>

Sign using some subset of required keys, returning any signing errors encountered. If recent_blockhash is not the same as currently in the transaction, clear any prior signatures and update recent_blockhash

pub fn try_partial_sign_unchecked<T: Signers>(
    &mut self,
    keypairs: &T,
    positions: Vec<usize>,
    recent_blockhash: Hash
) -> Result<(), SignerError>

Sign the transaction, returning any signing errors encountered, and place the signatures in their associated positions in signatures without checking that the positions are correct.

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

Verify the transaction

pub fn verify_and_hash_message(&self) -> Result<Hash>

Verify the transaction and hash its message

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

pub fn verify_precompiles(&self) -> Result<()>

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

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

pub fn replace_signatures(
    &mut self,
    signers: &[(Pubkey, Signature)]
) -> Result<()>

Replace all the signatures and pubkeys

pub fn is_signed(&self) -> bool

Trait Implementations

impl AbiExample for Transaction

fn example() -> Self

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 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 PartialEq<Transaction> 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: &Transaction) -> bool

This method tests for !=.

impl Sanitize for Transaction

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

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