Struct sugar_cli::withdraw::process::Transaction

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

An atomic transaction

Fields

signatures: Vec<Signature, Global>

A set of digital signatures of a serialized Message, signed by the first signatures.len() keys of account_keys.

message: Message

The message to sign.

Implementations

impl Transaction

pub fn new_unsigned(message: Message) -> Transaction

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

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

Create a signed transaction with the given payer.

Panics

Panics when signing fails.

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

Create a signed transaction.

Panics

Panics when signing fails.

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

Panics

Panics when signing fails.

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, Global>

Return the serialized message data to sign.

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

Check keys and keypair lengths, then sign this transaction.

Panics

Panics when signing fails, use Transaction::try_sign to handle the error.

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

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

Panics

Panics when signing fails, use Transaction::try_partial_sign to handle the error.

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

Sign the transaction and place the signatures in their associated positions in signatures without checking that the positions are correct.

Panics

Panics when 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, 

Check keys and keypair lengths, then sign this transaction, returning any signing errors encountered

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

Sign using some subset of required keys, returning any signing errors encountered. If recent_blockhash is not the same as currently in the transaction, clear any prior signatures and update recent_blockhash

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, returning any signing errors encountered, and place the signatures in their associated positions in signatures without checking that the positions are correct.

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

Verify the transaction

pub fn get_invalid_signature() -> Signature

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

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

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