Struct Address

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

A Unified Address.

Examples

use zcash_address::{
    unified::{self, Container, Encoding},
    ConversionError, TryFromRawAddress, ZcashAddress,
};

let example_ua: &str = address_from_user();

// We can parse this directly as a `unified::Address`:
let (network, ua) = unified::Address::decode(example_ua)?;

// Or we can parse via `ZcashAddress` (which you should do):
struct MyUnifiedAddress(unified::Address);
impl TryFromRawAddress for MyUnifiedAddress {
    // In this example we aren't checking the validity of the
    // inner Unified Address, but your code should do so!
    type Error = Infallible;

    fn try_from_raw_unified(ua: unified::Address) -> Result<Self, ConversionError<Self::Error>> {
        Ok(MyUnifiedAddress(ua))
    }
}
let addr: ZcashAddress = example_ua.parse()?;
let parsed = addr.convert_if_network::<MyUnifiedAddress>(network)?;
assert_eq!(parsed.0, ua);

// We can obtain the receivers for the UA in preference order
// (the order in which wallets should prefer to use them):
let receivers: Vec<unified::Receiver> = ua.items();

// And we can create the UA from a list of receivers:
let new_ua = unified::Address::try_from_items(receivers)?;
assert_eq!(new_ua, ua);

Implementations

impl Address

pub fn has_receiver_of_type(&self, pool_type: PoolType) -> bool

Returns whether this address has the ability to receive transfers of the given pool type.

pub fn contains_receiver(&self, receiver: &Receiver) -> bool

Returns whether this address contains the given receiver.

pub fn can_receive_memo(&self) -> bool

Returns whether this address can receive a memo.

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 Container for Address

type Item = Receiver

The type of item in this unified container.

fn items_as_parsed(&self) -> &[Receiver]

Returns the items in the order they were parsed from the string encoding.

fn items(&self) -> Vec<Self::Item>

Returns the items contained within this container, sorted in preference order.

impl Debug for Address

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

Formats the value using the given formatter.

impl Encoding for Address

fn try_from_items(items: Vec<Self::Item>) -> Result<Self, ParseError>

Constructs a value of a unified container type from a vector of container items, sorted according to typecode as specified in ZIP 316.

fn decode(s: &str) -> Result<(NetworkType, Self), ParseError>

Decodes a unified container from its string representation, preserving the order of its components so that it correctly obeys round-trip serialization invariants.

fn encode(&self, network: &NetworkType) -> String

Encodes the contents of the unified container to its string representation using the correct constants for the specified network, preserving the ordering of the contained items such that it correctly obeys round-trip serialization invariants.

impl Hash for Address

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 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 Eq for Address

impl StructuralPartialEq for Address