Struct Blob

pub struct Blob<const N: usize>(/* private fields */);

A fixed-size byte array wrapper for safely handling binary data of known length.

Blob<N> represents an immutable, fixed-size array of bytes that provides safe access and manipulation. It serves as a foundation for many domain-specific types in ZeWIF that need to represent fixed-length binary data, such as:

• Transaction IDs (32 bytes)
• Cryptographic keys (various lengths)
• Diversifier indices (11 bytes)
• Hashes and other cryptographic values

Zcash Concept Relation

In Zcash, many protocol elements are represented as fixed-size binary values with specific encodings. Blob<N> provides a type-safe way to handle these values and ensures they maintain their correct size throughout operations.

Data Preservation

Blob<N> preserves raw binary data exactly as it appears in wallet files, ensuring that cryptographic material and identifiers maintain their exact binary representation throughout the migration process.

Examples

Construction

// Create a blob with 32 bytes (common for transaction hashes)
let data = [0u8; 32];
let blob = Blob::new(data);

// Access data with index operations
assert_eq!(blob[0], 0);

// Convert to hex for display
let hex_string = hex::encode(blob.as_slice());

Implementations

impl<const N: usize> Blob<N>

pub fn new(data: [u8; N]) -> Self

Creates a new Blob from a fixed-size byte array.

This is the primary constructor for Blob<N> when you have an exact-sized array available.

Examples

let data = [1, 2, 3, 4];
let blob = Blob::new(data);

pub fn len(&self) -> usize

Returns the length of the blob in bytes.

This will always return the same value (N) for a given Blob<N> type.

Examples

let blob = Blob::<32>::default();
assert_eq!(blob.len(), 32);

pub fn is_empty(&self) -> bool

Returns true if the blob contains no bytes (N = 0).

Note: For most practical uses of Blob<N>, this will always return false as N is typically greater than 0.

Examples

let blob = Blob::<32>::default();
assert!(!blob.is_empty());

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

Converts the blob to a Vec<u8>, creating a copy of the data.

Examples

let blob = Blob::<4>::new([1, 2, 3, 4]);
let vec = blob.to_vec();
assert_eq!(vec, vec![1, 2, 3, 4]);

pub fn as_slice(&self) -> &[u8]

Returns a reference to the underlying byte array as a slice.

This is useful when you need to pass the blob’s contents to functions that accept slices.

Examples

let blob = Blob::<4>::new([1, 2, 3, 4]);
let slice = blob.as_slice();
assert_eq!(slice, &[1, 2, 3, 4]);

pub fn as_bytes(&self) -> &[u8; N]

exposes the underlying byte array.

pub fn from_slice(data: &[u8]) -> Result<Self, TryFromSliceError>

Creates a Blob from a slice of bytes.

Errors

Returns an error if the slice’s length doesn’t match the expected size N.

Examples

let slice = &[1, 2, 3, 4];
let blob = Blob::<4>::from_slice(slice).unwrap();
assert_eq!(blob.as_slice(), slice);

// This would fail:
let result = Blob::<5>::from_slice(slice);
assert!(result.is_err());

pub fn from_vec(data: Vec<u8>) -> Result<Self, TryFromSliceError>

Creates a Blob from a Vec<u8>.

Errors

Returns an error if the vector’s length doesn’t match the expected size N.

Examples

let vec = vec![1, 2, 3, 4];
let blob = Blob::<4>::from_vec(vec.clone()).unwrap();
assert_eq!(blob.to_vec(), vec);

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

Parses a Blob from a hexadecimal string.

Examples

let hex = "01020304";
let blob = Blob::<4>::from_hex(hex).unwrap();
assert_eq!(blob.as_slice(), &[1, 2, 3, 4]);

Trait Implementations

impl<const N: usize> AsRef<[u8]> for Blob<N>

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

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

impl<const N: usize> Clone for Blob<N>

fn clone(&self) -> Blob<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for Blob<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Blob<N>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Display for Blob<N>

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

Formats the value using the given formatter.

impl<const N: usize> From<&[u8]> for Blob<N>

fn from(data: &[u8]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<&[u8; N]> for Blob<N>

fn from(data: &[u8; N]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<&Blob<N>> for CBOR

fn from(data: &Blob<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<&Blob<N>> for Vec<u8>

fn from(blob: &Blob<N>) -> Vec<u8>

Converts to this type from the input type.

impl<const N: usize> From<Blob<N>> for [u8; N]

fn from(blob: Blob<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<Blob<N>> for CBOR

fn from(data: Blob<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<Blob<N>> for Envelope

fn from(value: Blob<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<Blob<N>> for Vec<u8>

fn from(blob: Blob<N>) -> Vec<u8>

Converts to this type from the input type.

impl<const N: usize> From<Vec<u8>> for Blob<N>

fn from(data: Vec<u8>) -> Self

Converts to this type from the input type.

impl<const N: usize> Hash for Blob<N>

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<const N: usize> Index<Range<usize>> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<RangeFrom<usize>> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<RangeFull> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<RangeInclusive<usize>> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: RangeInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<RangeTo<usize>> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<RangeToInclusive<usize>> for Blob<N>

type Output = [u8]

The returned type after indexing.

fn index(&self, range: RangeToInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> Index<usize> for Blob<N>

type Output = u8

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> IndexMut<usize> for Blob<N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<const N: usize> PartialEq for Blob<N>

fn eq(&self, other: &Blob<N>) -> 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<const N: usize> TryFrom<CBOR> for Blob<N>

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const N: usize> TryFrom<Envelope> for Blob<N>

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const N: usize> Eq for Blob<N>

impl<const N: usize> StructuralPartialEq for Blob<N>