Struct sugar_cli::withdraw::process::Transaction

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

An atomically-commited sequence of instructions.

While Instructions are the basic unit of computation in Solana, they are submitted by clients in Transactions containing one or more instructions, and signed by one or more Signers.

See the module documentation for more details about transactions.

Some constructors accept an optional payer, the account responsible for paying the cost of executing a transaction. In most cases, callers should specify the payer explicitly in these constructors. In some cases though, the caller is not required to specify the payer, but is still allowed to: in the Message structure, the first account is always the fee-payer, so if the caller has knowledge that the first account of the constructed transaction’s Message is both a signer and the expected fee-payer, then redundantly specifying the fee-payer is not strictly required.

Fields

signatures: Vec<Signature, Global>

A set of signatures of a serialized Message, signed by the first keys of the Message’s account_keys, where the number of signatures is equal to num_required_signatures of the Message’s MessageHeader.

message: Message

The message to sign.

Implementations

impl Transaction

pub fn new_unsigned(message: Message) -> Transaction

Create an unsigned transaction from a Message.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let message = Message::new(
        &[instruction],
        Some(&payer.pubkey()),
    );

    let mut tx = Transaction::new_unsigned(message);
    let blockhash = client.get_latest_blockhash()?;
    tx.sign(&[payer], blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Create a fully-signed transaction from a Message.

Panics

Panics when signing fails. See Transaction::try_sign and Transaction::try_partial_sign for a full description of failure scenarios.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let message = Message::new(
        &[instruction],
        Some(&payer.pubkey()),
    );

    let blockhash = client.get_latest_blockhash()?;
    let mut tx = Transaction::new(&[payer], message, blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Create an unsigned transaction from a list of Instructions.

payer is the account responsible for paying the cost of executing the transaction. It is typically provided, but is optional in some cases. See the Transaction docs for more.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let mut tx = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    let blockhash = client.get_latest_blockhash()?;
    tx.sign(&[payer], blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Create a fully-signed transaction from a list of Instructions.

payer is the account responsible for paying the cost of executing the transaction. It is typically provided, but is optional in some cases. See the Transaction docs for more.

Panics

Panics when signing fails. See Transaction::try_sign and Transaction::try_partial_sign for a full description of failure scenarios.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let blockhash = client.get_latest_blockhash()?;
    let mut tx = Transaction::new_signed_with_payer(
        &[instruction],
        Some(&payer.pubkey()),
        &[payer],
        blockhash,
    );
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Create a fully-signed transaction from pre-compiled instructions.

Arguments

• 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. See Transaction::try_sign and for a full description of failure conditions.

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

Get the data for an instruction at the given index.

The instruction_index corresponds to the instructions vector of the Transaction’s Message value.

Panics

Panics if instruction_index is greater than or equal to the number of instructions in the transaction.

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

Get the Pubkey of an account required by one of the instructions in the transaction.

The instruction_index corresponds to the instructions vector of the Transaction’s Message value; and the account_index to the accounts vector of the message’s CompiledInstructions.

Returns None if instruction_index is greater than or equal to the number of instructions in the transaction; or if accounts_index is greater than or equal to the number of accounts in the instruction.

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

Get the Pubkey of a signing account required by one of the instructions in the transaction.

The transaction does not need to be signed for this function to return a signing account’s pubkey.

Returns None if the indexed account is not required to sign the transaction. Returns None if the signatures field does not contain enough elements to hold a signature for the indexed account (this should only be possible if Transaction has been manually constructed).

Returns None if instruction_index is greater than or equal to the number of instructions in the transaction; or if accounts_index is greater than or equal to the number of accounts in the instruction.

pub fn message(&self) -> &Message

Return the message containing all data that should be signed.

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

Return the serialized message data to sign.

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

Sign the transaction.

This method fully signs a transaction with all required signers, which must be present in the keypairs slice. To sign with only some of the required signers, use Transaction::partial_sign.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Panics

Panics when signing fails. Use Transaction::try_sign to handle the error. See the documentation for Transaction::try_sign for a full description of failure conditions.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let mut tx = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    let blockhash = client.get_latest_blockhash()?;
    tx.sign(&[payer], blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Sign the transaction with a subset of required keys.

Unlike Transaction::sign, this method does not require all keypairs to be provided, allowing a transaction to be signed in multiple steps.

It is permitted to sign a transaction with the same keypair multiple times.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Panics

Panics when signing fails. Use Transaction::try_partial_sign to handle the error. See the documentation for Transaction::try_partial_sign for a full description of failure conditions.

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

Sign the transaction with a subset of required keys.

This places each of the signatures created from keypairs in the corresponding position, as specified in the positions vector, in the transactions signatures field. It does not verify that the signature positions are correct.

Panics

Panics if signing fails. Use Transaction::try_partial_sign_unchecked to handle the error.

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

Sign the transaction, returning any errors.

This method fully signs a transaction with all required signers, which must be present in the keypairs slice. To sign with only some of the required signers, use Transaction::try_partial_sign.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Errors

Signing will fail if some required signers are not provided in keypairs; or, if the transaction has previously been partially signed, some of the remaining required signers are not provided in keypairs. In other words, the transaction must be fully signed as a result of calling this function. The error is [SignerError::NotEnoughSigners].

Signing will fail for any of the reasons described in the documentation for Transaction::try_partial_sign.

Examples

This example uses the solana_client and anyhow crates.

use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_client::rpc_client::RpcClient;
use solana_sdk::{
     instruction::Instruction,
     message::Message,
     pubkey::Pubkey,
     signature::{Keypair, Signer},
     transaction::Transaction,
};

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let mut tx = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    let blockhash = client.get_latest_blockhash()?;
    tx.try_sign(&[payer], blockhash)?;
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}

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

Sign the transaction with a subset of required keys, returning any errors.

Unlike Transaction::try_sign, this method does not require all keypairs to be provided, allowing a transaction to be signed in multiple steps.

It is permitted to sign a transaction with the same keypair multiple times.

If recent_blockhash is different than recorded in the transaction message’s recent_blockhash field, then the message’s recent_blockhash will be updated to the provided recent_blockhash, and any prior signatures will be cleared.

Errors

Signing will fail if

• The transaction’s Message is malformed such that the number of required signatures recorded in its header (num_required_signatures) is greater than the length of its account keys (account_keys). The error is [SignerError::TransactionError] where the interior [TransactionError] is [TransactionError::InvalidAccountIndex].
• Any of the provided signers in keypairs is not a required signer of the message. The error is [SignerError::KeypairPubkeyMismatch].
• Any of the signers is a Presigner, and its provided signature is incorrect. The error is [SignerError::PresignerError] where the interior PresignerError is PresignerError::VerificationFailure.
• The signer is a RemoteKeypair and
  • It does not understand the input provided ([SignerError::InvalidInput]).
  • The device cannot be found ([SignerError::NoDeviceFound]).
  • The user cancels the signing ([SignerError::UserCancel]).
  • An error was encountered connecting ([SignerError::Connection]).
  • Some device-specific protocol error occurs ([SignerError::Protocol]).
  • Some other error occurs ([SignerError::Custom]).

See the documentation for the solana-remote-wallet crate for details on the operation of RemoteKeypair signers.

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

Sign the transaction with a subset of required keys, returning any errors.

This places each of the signatures created from keypairs in the corresponding position, as specified in the positions vector, in the transactions signatures field. It does not verify that the signature positions are correct.

Errors

Returns an error if signing fails.

pub fn get_invalid_signature() -> Signature

Returns a signature that is not valid for signing this transaction.

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

Verifies that all signers have signed the message.

Errors

Returns [TransactionError::SignatureFailure] on error.

pub fn verify_signatures_len(&self) -> bool

Verify the length of signatures matches the value in the message header

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

Verify the transaction and hash its message.

Errors

Returns [TransactionError::SignatureFailure] on error.

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

Verifies that all signers have signed the message.

Returns a vector with the length of required signatures, where each element is either true if that signer has signed, or false if not.

pub fn verify_precompiles(
    &self,
    feature_set: &Arc<FeatureSet>
) -> Result<(), TransactionError>

Verify the precompiled programs in this transaction.

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

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

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

Replace all the signatures and pubkeys.

pub fn is_signed(&self) -> bool

Trait Implementations

impl AbiExample for Transaction

fn example() -> Transaction

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<(), Error>

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<Transaction, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl FromWasmAbi for Transaction

type Abi = u32

The wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Transaction

Recover a Self from Self::Abi.

impl IntoWasmAbi for Transaction

type Abi = u32

The wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl OptionFromWasmAbi for Transaction

fn is_none(abi: &<Transaction as FromWasmAbi>::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for Transaction

fn none() -> <Transaction as IntoWasmAbi>::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

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

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, Transaction>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(
    js: <Transaction as RefFromWasmAbi>::Abi
) -> <Transaction as RefFromWasmAbi>::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for Transaction

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, Transaction>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(
    js: <Transaction as RefMutFromWasmAbi>::Abi
) -> <Transaction as RefMutFromWasmAbi>::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl Sanitize for Transaction

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

impl Serialize for Transaction

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction