Enum ProtocolAddress

pub enum ProtocolAddress {
    Transparent(Address),
    Sapling(Box<Address>),
    Unified(Box<UnifiedAddress>),
}

A protocol-specific Zcash address representation without additional metadata.

ProtocolAddress is an enum that distinguishes between the different address protocols supported in Zcash. It provides a type-safe way to handle the varied address formats while enabling common operations across all address types.

Zcash Concept Relation

Zcash has evolved through multiple address formats, each with different privacy and functionality characteristics:

• Transparent addresses (t-prefixed): Function like Bitcoin addresses, exposing all transaction details on the blockchain.

• Shielded addresses (z-prefixed): Use zero-knowledge proofs to encrypt transaction details. Originally included Sprout (legacy), now primarily Sapling (zs-prefixed) and Orchard (zo-prefixed) protocols.

• Unified addresses (u-prefixed): Introduced in NU5, these bundle multiple receiver types into a single address, allowing the sender’s wallet to automatically choose the most private protocol supported by both parties.

Data Preservation

During wallet migration, the complete address details from each protocol are preserved:

• For transparent addresses: Base58Check-encoded address strings and associated keys
• For shielded addresses: Encoded address strings, diversifiers, and viewing keys
• For unified addresses: All component addresses, diversifier indices, and metadata

Examples

// Create a transparent address
let t_addr = transparent::Address::new("t1example");
let t_protocol = ProtocolAddress::Transparent(t_addr);
assert!(t_protocol.is_transparent());

// Create a Sapling address
let s_addr = sapling::Address::new("zs1example".to_string());
let s_protocol = ProtocolAddress::Sapling(Box::new(s_addr));
assert!(s_protocol.is_sapling());

// Create a unified address
let u_addr = UnifiedAddress::new("u1example".to_string());
let u_protocol = ProtocolAddress::Unified(Box::new(u_addr));
assert!(u_protocol.is_unified());

// All protocol addresses can be converted to strings
assert!(t_protocol.as_string().starts_with("t1"));
assert!(s_protocol.as_string().starts_with("zs1"));
assert!(u_protocol.as_string().starts_with("u1"));

Variants

Transparent(Address)

An exposed transparent (T-address) similar to Bitcoin’s.

Sapling(Box<Address>)

A Sapling address (Z-address).

Unified(Box<UnifiedAddress>)

A unified address (U-address) that contains multiple receiver types.

Implementations

impl ProtocolAddress

pub fn as_string(&self) -> String

Returns the address as a string in its canonical format.

This method returns the string representation of the address, regardless of which protocol it uses. This is useful for display or storage where only the address string is needed.

Returns

A string representation of the address.

Examples

// Transparent address
let t_addr = transparent::Address::new("t1example");
let protocol = ProtocolAddress::Transparent(t_addr);
assert_eq!(protocol.as_string(), "t1example");

// Shielded address
let s_addr = sapling::Address::new("zs1example".to_string());
let protocol = ProtocolAddress::Sapling(Box::new(s_addr));
assert_eq!(protocol.as_string(), "zs1example");

pub fn is_sapling(&self) -> bool

Returns true if this is a Sapling address.

Returns

true if the address is a Sapling address (z-address), false otherwise.

Examples

// Create a Sapling address
let s_addr = sapling::Address::new("zs1example".to_string());
let address = ProtocolAddress::Sapling(Box::new(s_addr));
assert!(address.is_sapling());

// Create a transparent address
let t_addr = transparent::Address::new("t1example");
let address = ProtocolAddress::Transparent(t_addr);
assert!(!address.is_sapling());

pub fn is_transparent(&self) -> bool

Returns true if this is a transparent address.

Returns

true if the address is a transparent address (t-address), false otherwise.

Examples

// Create a transparent address
let t_addr = transparent::Address::new("t1example");
let address = ProtocolAddress::Transparent(t_addr);
assert!(address.is_transparent());

// Create a shielded address
let s_addr = sapling::Address::new("zs1example".to_string());
let address = ProtocolAddress::Sapling(Box::new(s_addr));
assert!(!address.is_transparent());

pub fn is_unified(&self) -> bool

Returns true if this is a unified address.

Returns

true if the address is a unified address (u-address), false otherwise.

Examples

// Create a unified address
let u_addr = UnifiedAddress::new("u1example".to_string());
let address = ProtocolAddress::Unified(Box::new(u_addr));
assert!(address.is_unified());

// Create a transparent address
let t_addr = transparent::Address::new("t1example");
let address = ProtocolAddress::Transparent(t_addr);
assert!(!address.is_unified());

Trait Implementations

impl Clone for ProtocolAddress

fn clone(&self) -> ProtocolAddress

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProtocolAddress

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

Formats the value using the given formatter.

impl From<ProtocolAddress> for Envelope

fn from(value: ProtocolAddress) -> Self

Converts to this type from the input type.

impl PartialEq for ProtocolAddress

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

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 ProtocolAddress