Struct VersionedTransaction

pub struct VersionedTransaction {
    pub signatures: Vec<Signature>,
    pub message: VersionedMessage,
}

An atomic transaction

Fields

signatures: Vec<Signature>

List of signatures

message: VersionedMessage

Message to sign.

Implementations

impl VersionedTransaction

pub fn try_new<T>( message: VersionedMessage, keypairs: &T, ) -> Result<VersionedTransaction, SignerError>

where T: Signers + ?Sized,

Signs a versioned message and if successful, returns a signed transaction.

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

pub fn version(&self) -> TransactionVersion

Returns the version of the transaction

pub fn into_legacy_transaction(self) -> Option<Transaction>

Returns a legacy transaction if the transaction message is legacy.

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>

Verify the transaction and return a list of verification results

pub fn uses_durable_nonce(&self) -> bool

Returns true if transaction begins with a valid advance nonce instruction. Since dynamically loaded addresses can’t have write locks demoted without loading addresses, this shouldn’t be used in the runtime.

Trait Implementations

impl AbiExample for VersionedTransaction

fn example() -> VersionedTransaction

impl Clone for VersionedTransaction

fn clone(&self) -> VersionedTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VersionedTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for VersionedTransaction

fn default() -> VersionedTransaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VersionedTransaction

fn deserialize<__D>( __deserializer: __D, ) -> Result<VersionedTransaction, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EncodableWithMeta for VersionedTransaction

type Encoded = EncodedTransaction

fn encode_with_meta( &self, encoding: UiTransactionEncoding, meta: &TransactionStatusMeta, ) -> <VersionedTransaction as EncodableWithMeta>::Encoded

fn json_encode(&self) -> <VersionedTransaction as EncodableWithMeta>::Encoded

impl From<Transaction> for VersionedTransaction

fn from(transaction: Transaction) -> VersionedTransaction

Converts to this type from the input type.

impl PartialEq for VersionedTransaction

fn eq(&self, other: &VersionedTransaction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

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

impl Serialize for VersionedTransaction

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 TryFrom<VersionedTransaction> for SanitizedVersionedTransaction

type Error = SanitizeError

The type returned in the event of a conversion error.

fn try_from( tx: VersionedTransaction, ) -> Result<SanitizedVersionedTransaction, <SanitizedVersionedTransaction as TryFrom<VersionedTransaction>>::Error>

Performs the conversion.

impl Eq for VersionedTransaction

impl StructuralPartialEq for VersionedTransaction