Struct BlockHash

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

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

BlockHash is a specialized wrapper around a 32-byte array representing a block’s unique identifier in the Zcash blockchain.

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

Block hashes 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 BlockHash 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 BlockHash from a byte array
let tx_bytes = [0u8; 32];
let txid = BlockHash::from_bytes(tx_bytes);

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

Implementations

impl BlockHash

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

Creates a new BlockHash from a 32-byte array.

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

Examples

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

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

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

Examples

let hex = "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f";
let block_hash = BlockHash::from_hex(hex).unwrap();
assert_eq!(block_hash.as_ref()[0], 0x6f);
assert_eq!(format!("{}", block_hash), hex);

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

Reads a BlockHash 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 BlockHash from the cursor
let txid = BlockHash::read(&mut cursor)?;

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

Writes a BlockHash 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 = BlockHash::from_bytes([0u8; 32]);
let mut buffer = Vec::new();

// Write the BlockHash 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 BlockHash

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

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

impl Clone for BlockHash

fn clone(&self) -> BlockHash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlockHash

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

Formats the value using the given formatter.

impl Display for BlockHash

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

Formats the value using the given formatter.

impl From<&BlockHash> for CBOR

fn from(value: &BlockHash) -> Self

Converts to this type from the input type.

impl From<BlockHash> for [u8; 32]

fn from(value: BlockHash) -> Self

Converts to this type from the input type.

impl From<BlockHash> for CBOR

fn from(value: BlockHash) -> Self

Converts to this type from the input type.

impl From<BlockHash> for Envelope

fn from(value: BlockHash) -> Self

Converts to this type from the input type.

impl Hash for BlockHash

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 BlockHash

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

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

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

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 BlockHash

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 BlockHash

impl Eq for BlockHash

impl StructuralPartialEq for BlockHash