Struct solana_sdk::transaction::Transaction

pub struct Transaction {
    pub signatures: Vec<Signature>,
    pub account_keys: Vec<Pubkey>,
    pub recent_blockhash: Hash,
    pub fee: u64,
    pub program_ids: Vec<Pubkey>,
    pub instructions: Vec<Instruction<u8, u8>>,
}

An atomic transaction

Fields

signatures: Vec<Signature>

A set of digital signatures of account_keys, program_ids, recent_blockhash, fee and instructions, signed by the first signatures.len() keys of account_keys

account_keys: Vec<Pubkey>

All the account keys used by this transaction

recent_blockhash: Hash

The id of a recent ledger entry.

fee: u64

The number of lamports paid for processing and storing of this transaction.

program_ids: Vec<Pubkey>

All the program id keys used to execute this transaction's instructions

instructions: Vec<Instruction<u8, u8>>

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

Methods

impl Transaction

pub fn new<S: Serialize, T: KeypairUtil>(
    from_keypair: &T,
    transaction_keys: &[Pubkey],
    program_id: &Pubkey,
    userdata: &S,
    recent_blockhash: Hash,
    fee: u64
) -> Self

pub fn new_unsigned<T: Serialize>(
    from_pubkey: &Pubkey,
    transaction_keys: &[Pubkey],
    program_id: &Pubkey,
    userdata: &T,
    recent_blockhash: Hash,
    fee: u64
) -> Self

pub fn new_with_instructions<T: KeypairUtil>(
    from_keypairs: &[&T],
    keys: &[Pubkey],
    recent_blockhash: Hash,
    fee: u64,
    program_ids: Vec<Pubkey>,
    instructions: Vec<Instruction<u8, u8>>
) -> Self

Create a signed transaction

• from_keypair - The key used to sign the transaction. This key is stored as keys[0]
• account_keys - The keys for the transaction. These are the program state instances or lamport recipient keys.
• recent_blockhash - The PoH hash.
• fee - The transaction fee.
• program_ids - The keys that identify programs used in the instruction vector.
• instructions - The programs and their arguments that the transaction will execute atomically

pub fn userdata(&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 program_id(&self, instruction_index: usize) -> &Pubkey

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

Get the transaction data to sign.

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

Sign this transaction.

pub fn sign_checked<T: KeypairUtil>(
    &mut self,
    keypairs: &[&T],
    recent_blockhash: Hash
)

Check keys and keypair lengths, then sign this transaction. Note: this presumes signatures.capacity() was set to the number of required signatures.

pub fn verify_signature(&self) -> bool

Verify only the transaction signature.

pub fn verify_refs(&self) -> bool

Verify that references in the instructions are valid

pub fn from(&self) -> &Pubkey

pub fn hash(transactions: &[Transaction]) -> Hash

pub fn serialized_size(&self) -> Result<u64, Error>

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