Struct solana_sdk::transaction::Transaction

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

An atomic transaction

Fields

signatures: Vec<Signature>

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

account_keys: Vec<Pubkey>

The Pubkeys that are executing this transaction userdata. The meaning of each key is program-specific.

• account_keys[0] - Typically this is the caller public key. signature is verified with account_keys[0]. In the future which key pays the fee and which keys have signatures would be configurable.
• account_keys[1] - Typically this is the program context or the recipient of the tokens

last_id: Hash

The ID of a recent ledger entry.

fee: u64

The number of tokens paid for processing and storage of this transaction.

program_ids: Vec<Pubkey>

Keys identifying programs in the instructions vector.

instructions: Vec<Instruction>

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

Implementations

impl Transaction

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

pub fn new_with_instructions(
    from_keypairs: &[&Keypair],
    keys: &[Pubkey],
    last_id: Hash,
    fee: u64,
    program_ids: Vec<Pubkey>,
    instructions: Vec<Instruction>
) -> 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 token recipient keys.
• last_id - 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 get_sign_data(&self) -> Vec<u8>

Get the transaction data to sign.

pub fn sign(&mut self, keypairs: &[&Keypair], last_id: Hash)

Sign this transaction.

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

Trait Implementations

impl BudgetTransaction for Transaction

fn budget_new_taxed(
    from_keypair: &Keypair,
    to: Pubkey,
    tokens: u64,
    fee: u64,
    last_id: Hash
) -> Self

Create and sign a new Transaction. Used for unit-testing.

fn budget_new(
    from_keypair: &Keypair,
    to: Pubkey,
    tokens: u64,
    last_id: Hash
) -> Self

Create and sign a new Transaction. Used for unit-testing.

fn budget_new_timestamp(
    from_keypair: &Keypair,
    contract: Pubkey,
    to: Pubkey,
    dt: DateTime<Utc>,
    last_id: Hash
) -> Self

Create and sign a new Witness Timestamp. Used for unit-testing.

fn budget_new_signature(
    from_keypair: &Keypair,
    contract: Pubkey,
    to: Pubkey,
    last_id: Hash
) -> Self

Create and sign a new Witness Signature. Used for unit-testing.

fn budget_new_on_date(
    from_keypair: &Keypair,
    to: Pubkey,
    contract: Pubkey,
    dt: DateTime<Utc>,
    dt_pubkey: Pubkey,
    cancelable: Option<Pubkey>,
    tokens: u64,
    last_id: Hash
) -> Self

Create and sign a postdated Transaction. Used for unit-testing.

fn budget_new_when_signed(
    from_keypair: &Keypair,
    to: Pubkey,
    contract: Pubkey,
    witness: Pubkey,
    cancelable: Option<Pubkey>,
    tokens: u64,
    last_id: Hash
) -> Self

Create and sign a multisig Transaction.

fn verify_plan(&self) -> bool

Verify only the payment plan.

fn instruction(&self, instruction_index: usize) -> Option<Instruction>

fn system_instruction(
    &self,
    instruction_index: usize
) -> Option<SystemInstruction>

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

fn loader_write(
    from_keypair: &Keypair,
    loader: Pubkey,
    offset: u32,
    bytes: Vec<u8>,
    last_id: Hash,
    fee: u64
) -> Self

fn loader_finalize(
    from_keypair: &Keypair,
    loader: Pubkey,
    last_id: Hash,
    fee: u64
) -> Self

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

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

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

fn storage_new_mining_proof(
    from_keypair: &Keypair,
    sha_state: Hash,
    last_id: Hash,
    entry_height: u64
) -> Self

impl SystemTransaction for Transaction

fn system_create(
    from_keypair: &Keypair,
    to: Pubkey,
    last_id: Hash,
    tokens: u64,
    space: u64,
    program_id: Pubkey,
    fee: u64
) -> Self

Create and sign new SystemInstruction::CreateAccount transaction

fn system_assign(
    from_keypair: &Keypair,
    last_id: Hash,
    program_id: Pubkey,
    fee: u64
) -> Self

Create and sign new SystemInstruction::Assign transaction

fn system_new(
    from_keypair: &Keypair,
    to: Pubkey,
    tokens: u64,
    last_id: Hash
) -> Self

Create and sign new SystemInstruction::CreateAccount transaction with some defaults

fn system_move(
    from_keypair: &Keypair,
    to: Pubkey,
    tokens: u64,
    last_id: Hash,
    fee: u64
) -> Self

Create and sign new SystemInstruction::Move transaction

fn system_move_many(
    from: &Keypair,
    moves: &[(Pubkey, u64)],
    last_id: Hash,
    fee: u64
) -> Self

Create and sign new SystemInstruction::Move transaction to many destinations

fn system_spawn(from_keypair: &Keypair, last_id: Hash, fee: u64) -> Self

Create and sign new SystemInstruction::Spawn transaction

impl VoteTransaction for Transaction

fn vote_new(vote_account: &Keypair, vote: Vote, last_id: Hash, fee: u64) -> Self

fn vote_account_new(
    validator_id: &Keypair,
    vote_account_id: Pubkey,
    last_id: Hash,
    num_tokens: u64,
    fee: u64
) -> Self

fn get_votes(&self) -> Vec<(Pubkey, Vote, Hash)>

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction