Struct SignedTransaction 

pub struct SignedTransaction<T>
where
    T: TransactionType,
{
    pub transaction: Transaction<T>,
    /* private fields */
}

A transaction that has been signed by its sender.

This structure wraps a transaction with its cryptographic signature, providing proof that the transaction was authorized by the sender.

Fields

transaction: Transaction<T>

The transaction that has been signed

Implementations

impl<T> SignedTransaction<T>

where T: TransactionType,

pub fn new( transaction: Transaction<T>, signature: Signature, ) -> Result<SignedTransaction<T>, TransactionValidationError>

Creates a new signed transaction and validates it.

This constructor ensures that the signature is valid for the transaction before creating the signed transaction instance.

Parameters

• transaction - transaction to be signed
• signature - cryptographic signature for the transaction

Errors

Returns a TransactionValidationError if:

• The signature cannot be verified; or
• The transaction itself is invalid.

pub fn tx_id(&self) -> HashDigest

Returns a unique identifier for this transaction.

pub fn validate_signed_tx(&self) -> Result<(), TransactionValidationError>

Validates both the signature and the transaction.

This method performs a complete validation by:

1. First verifying that the signature matches the transaction and signer; then
2. Validating the transaction itself according to its type-specific rules

Errors

Returns a TransactionValidationError if:

• The signature verification fails
• The transaction type-specific validation fails

pub const fn signature(&self) -> &Signature

Returns a reference to the transaction’s signature.

pub fn owner(&self) -> OwnerId

Returns the OwnerId of the transaction signer

Trait Implementations

impl<T> Clone for SignedTransaction<T>

where T: Clone + TransactionType,

fn clone(&self) -> SignedTransaction<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SignedTransaction<T>

where T: Debug + TransactionType,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for SignedTransaction<T>

where T: TransactionType + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> FromIterator<SignedTransaction<T>> for TransactionBundle<T>

where T: TransactionType,

fn from_iter<I>(iter: I) -> TransactionBundle<T>

where I: IntoIterator<Item = SignedTransaction<T>>,

Creates a value from an iterator.

impl<T> PartialEq for SignedTransaction<T>

where T: PartialEq + TransactionType,

fn eq(&self, other: &SignedTransaction<T>) -> 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<T> Serialize for SignedTransaction<T>

where T: TransactionType + Serialize,

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<T> TryFrom<SignedTransaction> for SignedTransaction<T>

where T: TransactionType + TryFrom<Transaction, Error = ProtoError>,

type Error = ProtoError

The type returned in the event of a conversion error.

fn try_from( wire_tx: SignedTransaction, ) -> Result<SignedTransaction<T>, <SignedTransaction<T> as TryFrom<SignedTransaction>>::Error>

Performs the conversion.

impl<T> TryHash256 for SignedTransaction<T>

where T: TransactionType,

fn try_hash_sha256(&self) -> Result<HashDigest, SerializationError>

Try to hash the type

impl<T> Eq for SignedTransaction<T>

where T: Eq + TransactionType,

impl<T> StructuralPartialEq for SignedTransaction<T>

where T: TransactionType,