Struct Transaction

pub struct Transaction { /* private fields */ }

A Zcash transaction that can combine transparent and multiple shielded protocol components.

Transaction represents a complete Zcash transaction, which can include components from transparent Bitcoin-style inputs/outputs as well as from any of the three Zcash shielded protocols: Sprout, Sapling, and Orchard. The transaction structure preserves both blockchain data (block height, timestamp) and the detailed components needed to represent the transaction in a wallet format.

Zcash Concept Relation

In Zcash:

• Unified Transaction Format: Transactions can seamlessly combine transparent and different shielded protocols in a single operation
• Multi-Protocol Support: Zcash has evolved through multiple shielded protocols, and transactions can include components from any of them:
  • Transparent (Bitcoin-style public inputs/outputs)
  • Sprout (original shielded protocol using JoinSplits)
  • Sapling (improved shielded protocol with separate spends/outputs)
  • Orchard (latest shielded protocol using unified actions)
• Transaction Lifecycle: Transactions go through stages (Pending, Confirmed, Failed, Abandoned) that represent their status on the blockchain

Data Preservation

During wallet migration, the following transaction data must be preserved:

• Identity: The unique transaction ID (txid)
• Blockchain Context: Block height, timestamp, block hash when available
• Status Information: Whether the transaction is pending, confirmed, failed, or abandoned
• Raw Transaction: Optional full binary transaction data
• Protocol-Specific Components:
  • Transparent inputs and outputs
  • Sapling spends and outputs
  • Orchard actions
  • Sprout JoinSplits

Examples

// Create a new transaction with a transaction ID (in practice, a real ID)
let txid = TxId::from_bytes([0u8; 32]);
let mut tx = Transaction::new(txid);

// Set transaction metadata
tx.set_mined_height(BlockHeight::from(1000000));

Implementations

impl Transaction

pub fn new(txid: TxId) -> Self

pub fn txid(&self) -> TxId

pub fn set_txid(&mut self, txid: TxId)

pub fn raw(&self) -> Option<&Data>

pub fn set_raw(&mut self, raw: Data)

pub fn target_height(&self) -> Option<&BlockHeight>

pub fn set_target_height(&mut self, height: BlockHeight)

pub fn mined_height(&self) -> Option<&BlockHeight>

pub fn set_mined_height(&mut self, height: BlockHeight)

pub fn block_position(&self) -> Option<&TxBlockPosition>

pub fn set_block_position(&mut self, block_position: Option<TxBlockPosition>)

Trait Implementations

impl Attachable for Transaction

fn attachments(&self) -> &Attachments

Returns a reference to the attachments container.

fn attachments_mut(&mut self) -> &mut Attachments

Returns a mutable reference to the attachments container.

fn add_attachment( &mut self, payload: impl EnvelopeEncodable, vendor: &str, conforms_to: Option<&str>, )

Adds a new attachment with the specified payload and metadata.

fn get_attachment(&self, digest: &Digest) -> Option<&Envelope>

Retrieves an attachment by its digest.

fn remove_attachment(&mut self, digest: &Digest) -> Option<Envelope>

Removes an attachment by its digest.

fn clear_attachments(&mut self)

Removes all attachments from the object.

fn has_attachments(&self) -> bool

Returns whether the object has any attachments.

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

Formats the value using the given formatter.

impl From<Transaction> for Envelope

fn from(value: Transaction) -> Self

Converts to this type from the input type.

impl PartialEq for Transaction

fn eq(&self, other: &Transaction) -> 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 TryFrom<Envelope> for Transaction

type Error = Error

The type returned in the event of a conversion error.

fn try_from(envelope: Envelope) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Transaction