Struct Transaction 

pub struct Transaction {
    pub signatures: Vec<PqSignature>,
    pub message: Message,
    pub tx_type: TransactionType,
}

Re-export transaction from core Signed transaction

Fields

signatures: Vec<PqSignature>

Transaction signatures. Each signature is self-contained: it carries both the signature bytes and the signer’s PQ verifying key.

message: Message

Transaction message

tx_type: TransactionType

Transaction type — determines processing path. Defaults to Native.

Implementations

impl Transaction

pub fn new(message: Message) -> Transaction

pub fn new_evm(message: Message) -> Transaction

Create a new EVM-typed transaction.

pub fn is_evm(&self) -> bool

Check if this is an EVM transaction (by type field or EVM replay sentinel).

pub fn signature(&self) -> Hash

Get transaction signature (first signature’s identifier)

pub fn message_hash(&self) -> Hash

Get the message-only hash (signing hash).

This is the hash that signers commit to via PQ signatures. It does NOT include signatures, so it is predictable before signing — useful for multi-sig coordination and client-side txid tracking before broadcast.

See also: hash() which includes signatures and serves as the canonical txid.

pub fn sender(&self) -> Pubkey

Get the sender/fee-payer (first account of first instruction)

pub fn hash(&self) -> Hash

Get transaction hash (includes the full signed envelope).

This is the canonical transaction ID stored in CF_TRANSACTIONS and returned by RPC methods. It equals SHA-256(bincode(transaction)).

Using the full serialized transaction keeps the txid aligned with the actual bytes propagated over the network, including the self-contained PQ signatures that carry signer public keys.

pub fn required_signers(&self) -> Result<HashSet<Pubkey>, String>

Collect the signer accounts required by this transaction.

pub fn verify_required_signatures(&self) -> Result<HashSet<Pubkey>, String>

Verify that every required signer has a valid PQ signature over the serialized transaction message.

pub fn validate_structure(&self) -> Result<(), String>

Validate transaction structure (size limits, T1.7)

pub fn to_wire(&self) -> Vec<u8>

Serialize to the V1 wire envelope: [magic_0, magic_1, version, type, ...bincode].

Callers that need base64 transport can encode the returned bytes with base64::encode(&tx.to_wire()).

pub fn from_wire( data: &[u8], max_wire_bytes: u64, ) -> Result<Transaction, String>

Deserialize from wire bytes, supporting three formats:

1. V1 envelope — starts with TX_WIRE_MAGIC ([0x4D, 0x54])
2. Raw bincode — bincode::serialize(&Transaction) output
3. JSON — { "signatures": [...], "message": {...} } from browser wallets

The max_wire_bytes parameter caps both JSON and bincode payloads before deserialization to prevent OOM from adversarial transaction submissions.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate 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<'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 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.