Struct Transaction 

pub struct Transaction {

    pub fee_payer: TnPubkey,
    pub program: TnPubkey,
    pub rw_accs: Option<Vec<TnPubkey>>,
    pub r_accs: Option<Vec<TnPubkey>>,
    pub instructions: Option<Vec<u8>>,
    pub fee: u64,
    pub req_compute_units: u32,
    pub req_state_units: u16,
    pub req_memory_units: u16,
    pub expiry_after: u32,
    pub start_slot: u64,
    pub nonce: u64,
    pub flags: u8,
    pub signature: Option<TnSignature>,
    pub fee_payer_state_proof: Option<StateProof>,
    pub fee_payer_account_meta_raw: Option<Vec<u8>>,
}

Normal Rust struct for transaction construction

Fields

fee_payer: TnPubkey

program: TnPubkey

rw_accs: Option<Vec<TnPubkey>>

r_accs: Option<Vec<TnPubkey>>

instructions: Option<Vec<u8>>

fee: u64

req_compute_units: u32

req_state_units: u16

req_memory_units: u16

expiry_after: u32

start_slot: u64

nonce: u64

flags: u8

signature: Option<TnSignature>

fee_payer_state_proof: Option<StateProof>

fee_payer_account_meta_raw: Option<Vec<u8>>

Implementations

impl Transaction

pub fn new(fee_payer: TnPubkey, program: TnPubkey, fee: u64, nonce: u64) -> Self

Create a new unsigned transaction

pub fn has_fee_payer_state_proof(&self) -> bool

pub fn may_compress_account(&self) -> bool

pub fn get_signature(&self) -> Option<Signature>

pub fn with_may_compress_account(self) -> Self

pub fn with_fee_payer_state_proof(self, state_proof: &StateProof) -> Self

Builder method: set fee payer state proof

pub fn with_fee_payer_account_meta_raw(self, account_meta_raw: Vec<u8>) -> Self

Builder method: set fee payer account meta as raw bytes

pub fn without_fee_payer_state_proof(self) -> Self

Builder method: remove fee payer state proof

pub fn with_rw_accounts(self, accounts: Vec<TnPubkey>) -> Self

Builder method: add read-write accounts

pub fn with_r_accounts(self, accounts: Vec<TnPubkey>) -> Self

Builder method: add read-only accounts

pub fn add_rw_account(self, account: TnPubkey) -> Self

Builder method: add a single read-write account

pub fn add_r_account(self, account: TnPubkey) -> Self

Builder method: add a single read-only account

pub fn with_instructions(self, instructions: Vec<u8>) -> Self

Builder method: add instruction data

pub fn with_compute_units(self, units: u32) -> Self

Builder method: set compute units

pub fn with_state_units(self, units: u16) -> Self

Builder method: set state units

pub fn with_memory_units(self, units: u16) -> Self

Builder method: set memory units

pub fn with_expiry_after(self, expiry: u32) -> Self

Builder method: set expiry

pub fn with_nonce(self, nonce: u64) -> Self

Builder method: set nonce

pub fn with_start_slot(self, slot: u64) -> Self

Builder method: set start slot

pub fn sign(&mut self, private_key: &[u8; 32]) -> Result<(), Box<dyn Error>>

Sign the transaction with a 32-byte Ed25519 private key

pub fn verify(&self) -> bool

Verify the transaction signature

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

Serialize to on-wire format (WireTxnHdrV1)

pub fn from_wire(bytes: &[u8]) -> Option<Self>

Deserialize from on-wire format (WireTxnHdrV1)

pub fn get_field_from_wire(bytes: &[u8], field: &str) -> Option<Vec<u8>>

Accessor: read a field from serialized bytes by name

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate 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.