Struct SignedTransaction 

pub struct SignedTransaction {
    pub transaction: Transaction,
    pub signature: Signature,
    pub pq_signature: Vec<u8>,
    /* private fields */
}

A signed transaction ready for submission

Contains the transaction and the composite signature (classical + post-quantum) proving authorization. Both legs are mandatory — there is no classical-only path. Verifiers reject a SignedTransaction whose pq_signature is absent or wrong-sized.

Wire layout

• signature — classical Ed25519 / Secp256k1 leg (existing field, raw bytes in signature.bytes and the classical pubkey in signature.public_key).
• pq_signature — ML-DSA-65 signature (FIPS 204, exactly 3309 bytes).
• The ML-DSA-65 verifying key lives in transaction.pq_public_key so that the hash preimage commits to the PQ identity.

Fields

transaction: Transaction

The underlying transaction

signature: Signature

The classical signature authorizing the transaction

pq_signature: Vec<u8>

ML-DSA-65 signature over transaction.hash() (FIPS 204, exactly 3309 bytes). Mandatory; mis-sized payloads are rejected at deserialization.

Implementations

impl SignedTransaction

pub fn new( transaction: Transaction, signature: Signature, pq_signature: Vec<u8>, ) -> Self

Creates a new signed transaction. Both the classical signature and the ML-DSA-65 signature are mandatory.

pub fn hash(&mut self) -> Hash

Returns the hash of the transaction

pub fn validate(&self) -> Result<(), &'static str>

Validates the signed transaction

Performs basic validation checks:

• Classical signature bytes are non-empty
• Classical public key is non-empty
• PQ signature is exactly ML_DSA_65_SIG_LEN bytes (3309)
• PQ public key (carried in transaction.pq_public_key) is exactly ML_DSA_65_VK_LEN bytes (1952)
• Gas limit is non-zero
• Addresses are non-zero
• Transaction data size is within limits

Note: This does NOT verify the cryptographic signature. Signature verification requires the crypto crate.

pub fn sender(&self) -> Address

Returns the sender address

pub fn recipient(&self) -> Address

Returns the recipient address

pub fn nonce(&self) -> Nonce

Returns the nonce

pub fn is_signed(&self) -> bool

Checks if the transaction has both classical and PQ signatures populated (non-empty classical legs and exact-size PQ legs). This does NOT verify cryptographic validity.

Trait Implementations

impl Clone for SignedTransaction

fn clone(&self) -> SignedTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignedTransaction

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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SignedTransaction

impl PartialEq for SignedTransaction

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SignedTransaction