Struct Address

pub struct Address { /* private fields */ }

A Zcash Sapling address and associated key data.

Sapling addresses rely on zero-knowledge proofs to validate transactions without revealing transaction details publicly. Each address can have associated keys:

• Spending Keys: Allow full control (viewing and spending)
• Viewing Keys: Allow monitoring transactions without spending capability
• Diversifiers: Enable generating multiple unique addresses from the same key material

Data Preservation

During wallet migration, the following components are preserved:

• Address strings: The canonical string representation (e.g., “zs1…”)
• Incoming Viewing Keys (IVKs): Preserved for transaction monitoring capability
• Spending Keys: Preserved for spending capability when available
• Diversifiers: Preserved to maintain address derivation capability
• HD paths: Preserved to maintain hierarchical wallet structure

Note: Full Viewing Keys (FVKs) are not stored separately because they can be derived from spending keys when needed, and source wallets typically don’t store them separately.

Examples

// Create a new Sapling shielded address
let mut address = sapling::Address::new("zs1exampleaddress".to_string());

// Associate an incoming viewing key (for monitoring transactions)
let ivk = SaplingIncomingViewingKey::new([0u8; 32]);
address.set_incoming_viewing_key(ivk);

// For addresses with spending capability, add a spending key
let spending_key = SaplingExtendedSpendingKey::new([0u8; 169]);
address.set_spending_key(spending_key);

// Set the diversifier if available
let diversifier_index = Blob::new([0; 11]);
address.set_diversifier_index(diversifier_index);

// Set HD derivation path information
address.set_hd_derivation_path("m/32'/1'/0'/0/5".to_string());

Implementations

impl Address

pub fn new(address: String) -> Self

pub fn address(&self) -> &str

pub fn set_address(&mut self, address: String)

pub fn incoming_viewing_key(&self) -> Option<&SaplingIncomingViewingKey>

Returns the Incoming Viewing Key (IVK) associated with this address, if available.

The IVK enables viewing incoming transactions without granting spending capability. During wallet migration, IVKs are preserved exactly as they exist in the source wallet.

Returns

• Some(&SaplingIncomingViewingKey) if an IVK is associated with this address
• None if no IVK is available (common for addresses without viewing capability)

pub fn set_incoming_viewing_key(&mut self, ivk: SaplingIncomingViewingKey)

Associates an Incoming Viewing Key (IVK) with this shielded address.

This method is primarily used during wallet migration to preserve viewing capability for existing addresses. An IVK enables the wallet to scan the blockchain for incoming transactions without revealing transaction details publicly.

Parameters

• ivk: The 32-byte Sapling Incoming Viewing Key to associate with this address

pub fn full_viewing_key(&self) -> Option<&SaplingExtendedFullViewingKey>

pub fn set_full_viewing_key(&mut self, key: SaplingExtendedFullViewingKey)

pub fn spending_key(&self) -> Option<&SaplingExtendedSpendingKey>

pub fn set_spending_key(&mut self, key: SaplingExtendedSpendingKey)

pub fn diversifier_index(&self) -> Option<&Blob<11>>

pub fn set_diversifier_index(&mut self, d: Blob<11>)

pub fn hd_derivation_path(&self) -> Option<&str>

Get the HD derivation path for this address, if available

pub fn set_hd_derivation_path(&mut self, path: String)

Set the HD derivation path for this address

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl From<Address> for Envelope

fn from(value: Address) -> Self

Converts to this type from the input type.

impl PartialEq for Address

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

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 Address