Struct TxId

pub struct TxId(/* private fields */);

A transaction identifier (TxId) represented as a 32-byte hash.

TxId is a specialized wrapper around a 32-byte array representing a transaction’s unique identifier in the Zcash blockchain. Transaction IDs are double-SHA256 hashes of the transaction data (with specific rules for what parts are included in the hash).

Zcash Concept Relation

In Zcash (and Bitcoin-derived cryptocurrencies), transaction IDs are critical identifiers used to reference transactions throughout the protocol:

• In transaction inputs to reference previous outputs being spent
• In block data structures to identify included transactions
• In client APIs and explorers to look up transaction details

Transaction IDs are displayed in reverse byte order by convention (to match Bitcoin’s historical display format), while stored internally in little-endian order.

Data Preservation

The TxId type preserves the exact 32-byte transaction identifier as found in wallet data files, ensuring that transaction references maintain their cryptographic integrity during wallet migrations.

Examples

// Create a TxId from a byte array
let tx_bytes = [0u8; 32];
let txid = TxId::from_bytes(tx_bytes);

// Display the TxId in the conventional reversed format used by explorers
// Note: this would display as a string of 64 hex characters (zeros in this example)
println!("Transaction ID: {}", txid);

Implementations

impl TxId

pub fn from_bytes(bytes: [u8; 32]) -> Self

Creates a new TxId from a 32-byte array.

This is the primary constructor for TxId when you have the raw transaction hash available.

Examples

// Usually this would be a real transaction hash
let bytes = [0u8; 32];
let txid = TxId::from_bytes(bytes);

pub fn from_hex(hex: &str) -> Result<Self, HexParseError>

Parses a TxId from a canonically-encoded (byte-reversed) hexadecimal string.

Examples

let hex = "0000000000000000000000000000000000000000000000000000000000000001";
let blob = TxId::from_hex(hex).unwrap();
let mut expected = [0u8; 32];
expected[0] = 1;
assert_eq!(blob.as_ref(), &expected);

pub fn read<R: Read>(reader: R) -> Result<Self>

Reads a TxId from any source implementing the Read trait.

This method is useful when reading transaction IDs directly from files or other byte streams.

Errors

Returns an IO error if reading fails or if there aren’t enough bytes available.

Examples

// Create a cursor with 32 bytes
let data = vec![0u8; 32];
let mut cursor = Cursor::new(data);

// Read a TxId from the cursor
let txid = TxId::read(&mut cursor)?;

pub fn write<W: Write>(&self, writer: W) -> Result<()>

Writes a TxId to any destination implementing the Write trait.

This method is useful when serializing transaction IDs to files or other byte streams.

Errors

Returns an IO error if writing fails.

Examples

let txid = TxId::from_bytes([0u8; 32]);
let mut buffer = Vec::new();

// Write the TxId to the buffer
txid.write(&mut buffer)?;

// The buffer now contains the 32-byte transaction ID
assert_eq!(buffer.len(), 32);

Trait Implementations

impl AsRef<[u8; 32]> for TxId

fn as_ref(&self) -> &[u8; 32]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TxId

fn clone(&self) -> TxId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TxId

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

Formats the value using the given formatter.

impl Display for TxId

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

Formats the value using the given formatter.

impl From<&TxId> for CBOR

fn from(value: &TxId) -> Self

Converts to this type from the input type.

impl From<TxId> for [u8; 32]

fn from(value: TxId) -> Self

Converts to this type from the input type.

impl From<TxId> for CBOR

fn from(value: TxId) -> Self

Converts to this type from the input type.

impl From<TxId> for Envelope

fn from(value: TxId) -> Self

Converts to this type from the input type.

impl Hash for TxId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for TxId

fn cmp(&self, other: &TxId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for TxId

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

fn partial_cmp(&self, other: &TxId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<CBOR> for TxId

type Error = Error

The type returned in the event of a conversion error.

fn try_from(cbor: CBOR) -> Result<Self>

Performs the conversion.

impl TryFrom<Envelope> for TxId

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 Copy for TxId

impl Eq for TxId

impl StructuralPartialEq for TxId