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

message: Message

The message to sign.

Methods

impl Transaction

pub fn new_unsigned(message: Message) -> Self

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

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

pub fn new_unsigned_instructions(instructions: Vec<Instruction>) -> Self

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

pub fn new_signed_instructions<T: KeypairUtil>(
    from_keypairs: &[&T],
    instructions: Vec<Instruction>,
    recent_blockhash: Hash
) -> Transaction

pub fn new_with_compiled_instructions<T: KeypairUtil>(
    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.

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: KeypairUtil>(&mut self, keypairs: &[&T], recent_blockhash: Hash)

Check keys and keypair lengths, then sign this transaction.

pub fn partial_sign<T: KeypairUtil>(
    &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

pub fn partial_sign_unchecked<T: KeypairUtil>(
    &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.

pub fn get_signing_keypair_positions<T: KeypairUtil>(
    &self,
    keypairs: &[&T]
) -> Result<Vec<Option<usize>>>

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

pub fn is_signed(&self) -> bool

pub fn verify_refs(&self) -> bool

Verify that references in the instructions are valid

Trait Implementations

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

impl Debug for Transaction

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

Formats the value using the given formatter.

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<'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.